211 files changed, 1439 insertions, 1439 deletions

diff --git a/src/AllocationPool.h b/src/AllocationPool.h
index 61431a548..7c358cc84 100644
--- a/src/AllocationPool.h
+++ b/src/AllocationPool.h
@@ -45,7 +45,7 @@ class cListAllocationPool : public cAllocationPool<T>
 			for (size_t i = 0; i < NumElementsInReserve; i++)
 			{
 				void * space = malloc(sizeof(T));
-				if (space == NULL)
+				if (space == nullptr)
 				{
 					m_Callbacks->OnStartUsingReserve();
 					break;
@@ -68,7 +68,7 @@ class cListAllocationPool : public cAllocationPool<T>
 			if (m_FreeList.size() <= NumElementsInReserve)
 			{
 				void * space = malloc(sizeof(T));
-				if (space != NULL)
+				if (space != nullptr)
 				{
 					return new(space) T;
 				}
@@ -90,7 +90,7 @@ class cListAllocationPool : public cAllocationPool<T>
 		}
 		virtual void Free(T * a_ptr) override
 		{
-			if (a_ptr == NULL)
+			if (a_ptr == nullptr)
 			{
 				return;
 			}
diff --git a/src/Bindings/DeprecatedBindings.cpp b/src/Bindings/DeprecatedBindings.cpp
index 02aa15be4..ded7a0142 100644
--- a/src/Bindings/DeprecatedBindings.cpp
+++ b/src/Bindings/DeprecatedBindings.cpp
@@ -29,7 +29,7 @@ static int tolua_get_AllToLua_g_BlockLightValue(lua_State* tolua_S)
 	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
 	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
 	{
-		tolua_error(tolua_S, "array indexing out of range.", NULL);
+		tolua_error(tolua_S, "array indexing out of range.", nullptr);
 	}
 	tolua_pushnumber(tolua_S, (lua_Number)cBlockInfo::GetLightValue((BLOCKTYPE)BlockType));
 	return 1;
@@ -55,7 +55,7 @@ static int tolua_get_AllToLua_g_BlockSpreadLightFalloff(lua_State* tolua_S)
 	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
 	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
 	{
-		tolua_error(tolua_S, "array indexing out of range.", NULL);
+		tolua_error(tolua_S, "array indexing out of range.", nullptr);
 	}
 	tolua_pushnumber(tolua_S, (lua_Number)cBlockInfo::GetSpreadLightFalloff((BLOCKTYPE)BlockType));
 	return 1;
@@ -81,7 +81,7 @@ static int tolua_get_AllToLua_g_BlockTransparent(lua_State* tolua_S)
 	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
 	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
 	{
-		tolua_error(tolua_S, "array indexing out of range.", NULL);
+		tolua_error(tolua_S, "array indexing out of range.", nullptr);
 	}
 	tolua_pushboolean(tolua_S, cBlockInfo::IsTransparent((BLOCKTYPE)BlockType));
 	return 1;
@@ -107,7 +107,7 @@ static int tolua_get_AllToLua_g_BlockOneHitDig(lua_State* tolua_S)
 	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
 	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
 	{
-		tolua_error(tolua_S, "array indexing out of range.", NULL);
+		tolua_error(tolua_S, "array indexing out of range.", nullptr);
 	}
 	tolua_pushboolean(tolua_S, cBlockInfo::IsOneHitDig((BLOCKTYPE)BlockType));
 	return 1;
@@ -133,7 +133,7 @@ static int tolua_get_AllToLua_g_BlockPistonBreakable(lua_State* tolua_S)
 	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
 	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
 	{
-		tolua_error(tolua_S, "array indexing out of range.", NULL);
+		tolua_error(tolua_S, "array indexing out of range.", nullptr);
 	}
 	tolua_pushboolean(tolua_S, cBlockInfo::IsPistonBreakable((BLOCKTYPE)BlockType));
 	return 1;
@@ -159,7 +159,7 @@ static int tolua_get_AllToLua_g_BlockIsSnowable(lua_State* tolua_S)
 	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
 	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
 	{
-		tolua_error(tolua_S, "array indexing out of range.", NULL);
+		tolua_error(tolua_S, "array indexing out of range.", nullptr);
 	}
 	tolua_pushboolean(tolua_S, cBlockInfo::IsSnowable((BLOCKTYPE)BlockType));
 	return 1;
@@ -185,7 +185,7 @@ static int tolua_get_AllToLua_g_BlockIsSolid(lua_State* tolua_S)
 	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
 	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
 	{
-		tolua_error(tolua_S, "array indexing out of range.", NULL);
+		tolua_error(tolua_S, "array indexing out of range.", nullptr);
 	}
 	tolua_pushboolean(tolua_S, (bool)cBlockInfo::IsSolid((BLOCKTYPE)BlockType));
 	return 1;
@@ -211,7 +211,7 @@ static int tolua_get_AllToLua_g_BlockFullyOccupiesVoxel(lua_State* tolua_S)
 	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
 	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
 	{
-		tolua_error(tolua_S, "array indexing out of range.", NULL);
+		tolua_error(tolua_S, "array indexing out of range.", nullptr);
 	}
 	tolua_pushboolean(tolua_S, (bool)cBlockInfo::FullyOccupiesVoxel((BLOCKTYPE)BlockType));
 	return 1;
@@ -224,16 +224,16 @@ static int tolua_get_AllToLua_g_BlockFullyOccupiesVoxel(lua_State* tolua_S)
 
 void DeprecatedBindings::Bind(lua_State * tolua_S)
 {
-	tolua_beginmodule(tolua_S, NULL);
-
-	tolua_array(tolua_S, "g_BlockLightValue",          tolua_get_AllToLua_g_BlockLightValue,          NULL);
-	tolua_array(tolua_S, "g_BlockSpreadLightFalloff",  tolua_get_AllToLua_g_BlockSpreadLightFalloff,  NULL);
-	tolua_array(tolua_S, "g_BlockTransparent",         tolua_get_AllToLua_g_BlockTransparent,         NULL);
-	tolua_array(tolua_S, "g_BlockOneHitDig",           tolua_get_AllToLua_g_BlockOneHitDig,           NULL);
-	tolua_array(tolua_S, "g_BlockPistonBreakable",     tolua_get_AllToLua_g_BlockPistonBreakable,     NULL);
-	tolua_array(tolua_S, "g_BlockIsSnowable",          tolua_get_AllToLua_g_BlockIsSnowable,          NULL);
-	tolua_array(tolua_S, "g_BlockIsSolid",             tolua_get_AllToLua_g_BlockIsSolid,             NULL);
-	tolua_array(tolua_S, "g_BlockFullyOccupiesVoxel",  tolua_get_AllToLua_g_BlockFullyOccupiesVoxel,  NULL);
+	tolua_beginmodule(tolua_S, nullptr);
+
+	tolua_array(tolua_S, "g_BlockLightValue",          tolua_get_AllToLua_g_BlockLightValue,          nullptr);
+	tolua_array(tolua_S, "g_BlockSpreadLightFalloff",  tolua_get_AllToLua_g_BlockSpreadLightFalloff,  nullptr);
+	tolua_array(tolua_S, "g_BlockTransparent",         tolua_get_AllToLua_g_BlockTransparent,         nullptr);
+	tolua_array(tolua_S, "g_BlockOneHitDig",           tolua_get_AllToLua_g_BlockOneHitDig,           nullptr);
+	tolua_array(tolua_S, "g_BlockPistonBreakable",     tolua_get_AllToLua_g_BlockPistonBreakable,     nullptr);
+	tolua_array(tolua_S, "g_BlockIsSnowable",          tolua_get_AllToLua_g_BlockIsSnowable,          nullptr);
+	tolua_array(tolua_S, "g_BlockIsSolid",             tolua_get_AllToLua_g_BlockIsSolid,             nullptr);
+	tolua_array(tolua_S, "g_BlockFullyOccupiesVoxel",  tolua_get_AllToLua_g_BlockFullyOccupiesVoxel,  nullptr);
 
 	tolua_endmodule(tolua_S);
 }
diff --git a/src/Bindings/LuaChunkStay.cpp b/src/Bindings/LuaChunkStay.cpp
index 23da12f68..e50ffb75b 100644
--- a/src/Bindings/LuaChunkStay.cpp
+++ b/src/Bindings/LuaChunkStay.cpp
@@ -13,7 +13,7 @@
 
 cLuaChunkStay::cLuaChunkStay(cPluginLua & a_Plugin) :
 	m_Plugin(a_Plugin),
-	m_LuaState(NULL)
+	m_LuaState(nullptr)
 {
 }
 
diff --git a/src/Bindings/LuaState.cpp b/src/Bindings/LuaState.cpp
index 142242162..3b4ce3376 100644
--- a/src/Bindings/LuaState.cpp
+++ b/src/Bindings/LuaState.cpp
@@ -46,7 +46,7 @@ const cLuaState::cRet cLuaState::Return = {};
 // cLuaState:
 
 cLuaState::cLuaState(const AString & a_SubsystemName) :
-	m_LuaState(NULL),
+	m_LuaState(nullptr),
 	m_IsOwned(false),
 	m_SubsystemName(a_SubsystemName),
 	m_NumCurrentFunctionArgs(-1)
@@ -90,7 +90,7 @@ cLuaState::~cLuaState()
 
 void cLuaState::Create(void)
 {
-	if (m_LuaState != NULL)
+	if (m_LuaState != nullptr)
 	{
 		LOGWARNING("%s: Trying to create an already-existing LuaState, ignoring.", __FUNCTION__);
 		return;
@@ -119,7 +119,7 @@ void cLuaState::RegisterAPILibs(void)
 
 void cLuaState::Close(void)
 {
-	if (m_LuaState == NULL)
+	if (m_LuaState == nullptr)
 	{
 		LOGWARNING("%s: Trying to close an invalid LuaState, ignoring.", __FUNCTION__);
 		return;
@@ -134,7 +134,7 @@ void cLuaState::Close(void)
 		return;
 	}
 	lua_close(m_LuaState);
-	m_LuaState = NULL;
+	m_LuaState = nullptr;
 	m_IsOwned = false;
 }
 
@@ -144,7 +144,7 @@ void cLuaState::Close(void)
 
 void cLuaState::Attach(lua_State * a_State)
 {
-	if (m_LuaState != NULL)
+	if (m_LuaState != nullptr)
 	{
 		LOGINFO("%s: Already contains a LuaState (0x%p), will be closed / detached.", __FUNCTION__, m_LuaState);
 		if (m_IsOwned)
@@ -166,7 +166,7 @@ void cLuaState::Attach(lua_State * a_State)
 
 void cLuaState::Detach(void)
 {
-	if (m_LuaState == NULL)
+	if (m_LuaState == nullptr)
 	{
 		return;
 	}
@@ -179,7 +179,7 @@ void cLuaState::Detach(void)
 		Close();
 		return;
 	}
-	m_LuaState = NULL;
+	m_LuaState = nullptr;
 }
 
 
@@ -828,7 +828,7 @@ void cLuaState::GetStackValue(int a_StackPos, AString & a_Value)
 {
 	size_t len = 0;
 	const char * data = lua_tolstring(m_LuaState, a_StackPos, &len);
-	if (data != NULL)
+	if (data != nullptr)
 	{
 		a_Value.assign(data, len);
 	}
@@ -878,7 +878,7 @@ void cLuaState::GetStackValue(int a_StackPos, pBoundingBox & a_ReturnedVal)
 {
 	if (lua_isnil(m_LuaState, a_StackPos))
 	{
-		a_ReturnedVal = NULL;
+		a_ReturnedVal = nullptr;
 		return;
 	}
 	tolua_Error err;
@@ -896,7 +896,7 @@ void cLuaState::GetStackValue(int a_StackPos, pWorld & a_ReturnedVal)
 {
 	if (lua_isnil(m_LuaState, a_StackPos))
 	{
-		a_ReturnedVal = NULL;
+		a_ReturnedVal = nullptr;
 		return;
 	}
 	tolua_Error err;
@@ -961,7 +961,7 @@ bool cLuaState::CheckParamUserTable(int a_StartParam, const char * a_UserTable,
 		lua_Debug entry;
 		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
 		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
-		AString ErrMsg = Printf("#ferror in function '%s'.", (entry.name != NULL) ? entry.name : "?");
+		AString ErrMsg = Printf("#ferror in function '%s'.", (entry.name != nullptr) ? entry.name : "?");
 		tolua_error(m_LuaState, ErrMsg.c_str(), &tolua_err);
 		return false;
 	}  // for i - Param
@@ -994,7 +994,7 @@ bool cLuaState::CheckParamUserType(int a_StartParam, const char * a_UserType, in
 		lua_Debug entry;
 		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
 		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
-		AString ErrMsg = Printf("#ferror in function '%s'.", (entry.name != NULL) ? entry.name : "?");
+		AString ErrMsg = Printf("#ferror in function '%s'.", (entry.name != nullptr) ? entry.name : "?");
 		tolua_error(m_LuaState, ErrMsg.c_str(), &tolua_err);
 		return false;
 	}  // for i - Param
@@ -1027,7 +1027,7 @@ bool cLuaState::CheckParamTable(int a_StartParam, int a_EndParam)
 		lua_Debug entry;
 		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
 		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
-		AString ErrMsg = Printf("#ferror in function '%s'.", (entry.name != NULL) ? entry.name : "?");
+		AString ErrMsg = Printf("#ferror in function '%s'.", (entry.name != nullptr) ? entry.name : "?");
 		tolua_error(m_LuaState, ErrMsg.c_str(), &tolua_err);
 		return false;
 	}  // for i - Param
@@ -1060,7 +1060,7 @@ bool cLuaState::CheckParamNumber(int a_StartParam, int a_EndParam)
 		lua_Debug entry;
 		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
 		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
-		AString ErrMsg = Printf("#ferror in function '%s'.", (entry.name != NULL) ? entry.name : "?");
+		AString ErrMsg = Printf("#ferror in function '%s'.", (entry.name != nullptr) ? entry.name : "?");
 		tolua_error(m_LuaState, ErrMsg.c_str(), &tolua_err);
 		return false;
 	}  // for i - Param
@@ -1093,7 +1093,7 @@ bool cLuaState::CheckParamString(int a_StartParam, int a_EndParam)
 		lua_Debug entry;
 		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
 		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
-		AString ErrMsg = Printf("#ferror in function '%s'.", (entry.name != NULL) ? entry.name : "?");
+		AString ErrMsg = Printf("#ferror in function '%s'.", (entry.name != nullptr) ? entry.name : "?");
 		tolua_error(m_LuaState, ErrMsg.c_str(), &tolua_err);
 		return false;
 	}  // for i - Param
@@ -1126,7 +1126,7 @@ bool cLuaState::CheckParamFunction(int a_StartParam, int a_EndParam)
 		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
 		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
 		luaL_error(m_LuaState, "Error in function '%s' parameter #%d. Function expected, got %s",
-			(entry.name != NULL) ? entry.name : "?", i, GetTypeText(i).c_str()
+			(entry.name != nullptr) ? entry.name : "?", i, GetTypeText(i).c_str()
 		);
 		return false;
 	}  // for i - Param
@@ -1159,7 +1159,7 @@ bool cLuaState::CheckParamFunctionOrNil(int a_StartParam, int a_EndParam)
 		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
 		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
 		luaL_error(m_LuaState, "Error in function '%s' parameter #%d. Function expected, got %s",
-			(entry.name != NULL) ? entry.name : "?", i, GetTypeText(i).c_str()
+			(entry.name != nullptr) ? entry.name : "?", i, GetTypeText(i).c_str()
 		);
 		return false;
 	}  // for i - Param
@@ -1183,7 +1183,7 @@ bool cLuaState::CheckParamEnd(int a_Param)
 	lua_Debug entry;
 	VERIFY(lua_getstack(m_LuaState, 0,   &entry));
 	VERIFY(lua_getinfo (m_LuaState, "n", &entry));
-	AString ErrMsg = Printf("#ferror in function '%s': Too many arguments.", (entry.name != NULL) ? entry.name : "?");
+	AString ErrMsg = Printf("#ferror in function '%s': Too many arguments.", (entry.name != nullptr) ? entry.name : "?");
 	tolua_error(m_LuaState, ErrMsg.c_str(), &tolua_err);
 	return false;
 }
@@ -1362,7 +1362,7 @@ int cLuaState::CopyStackFrom(cLuaState & a_SrcLuaState, int a_SrcStart, int a_Sr
 			case LUA_TUSERDATA:
 			{
 				// Get the class name:
-				const char * type = NULL;
+				const char * type = nullptr;
 				if (lua_getmetatable(a_SrcLuaState, i) == 0)
 				{
 					LOGWARNING("%s: Unknown class in pos %d, cannot copy.", __FUNCTION__, i);
@@ -1374,7 +1374,7 @@ int cLuaState::CopyStackFrom(cLuaState & a_SrcLuaState, int a_SrcStart, int a_Sr
 				lua_pop(a_SrcLuaState, 1);                     // Stack -1
 				
 				// Copy the value:
-				void * ud = tolua_touserdata(a_SrcLuaState, i, NULL);
+				void * ud = tolua_touserdata(a_SrcLuaState, i, nullptr);
 				tolua_pushusertype(m_LuaState, ud, type);
 				break;
 			}
@@ -1400,7 +1400,7 @@ void cLuaState::ToString(int a_StackPos, AString & a_String)
 {
 	size_t len;
 	const char * s = lua_tolstring(m_LuaState, a_StackPos, &len);
-	if (s != NULL)
+	if (s != nullptr)
 	{
 		a_String.assign(s, len);
 	}
@@ -1422,7 +1422,7 @@ void cLuaState::LogStack(const char * a_Header)
 void cLuaState::LogStack(lua_State * a_LuaState, const char * a_Header)
 {
 	// Format string consisting only of %s is used to appease the compiler
-	LOG("%s", (a_Header != NULL) ? a_Header : "Lua C API Stack contents:");
+	LOG("%s", (a_Header != nullptr) ? a_Header : "Lua C API Stack contents:");
 	for (int i = lua_gettop(a_LuaState); i > 0; i--)
 	{
 		AString Value;
@@ -1459,7 +1459,7 @@ int cLuaState::ReportFnCallErrors(lua_State * a_LuaState)
 // cLuaState::cRef:
 
 cLuaState::cRef::cRef(void) :
-	m_LuaState(NULL),
+	m_LuaState(nullptr),
 	m_Ref(LUA_REFNIL)
 {
 }
@@ -1469,7 +1469,7 @@ cLuaState::cRef::cRef(void) :
 
 
 cLuaState::cRef::cRef(cLuaState & a_LuaState, int a_StackPos) :
-	m_LuaState(NULL),
+	m_LuaState(nullptr),
 	m_Ref(LUA_REFNIL)
 {
 	RefStack(a_LuaState, a_StackPos);
@@ -1481,7 +1481,7 @@ cLuaState::cRef::cRef(cLuaState & a_LuaState, int a_StackPos) :
 
 cLuaState::cRef::~cRef()
 {
-	if (m_LuaState != NULL)
+	if (m_LuaState != nullptr)
 	{
 		UnRef();
 	}
@@ -1494,7 +1494,7 @@ cLuaState::cRef::~cRef()
 void cLuaState::cRef::RefStack(cLuaState & a_LuaState, int a_StackPos)
 {
 	ASSERT(a_LuaState.IsValid());
-	if (m_LuaState != NULL)
+	if (m_LuaState != nullptr)
 	{
 		UnRef();
 	}
@@ -1515,7 +1515,7 @@ void cLuaState::cRef::UnRef(void)
 	{
 		luaL_unref(*m_LuaState, LUA_REGISTRYINDEX, m_Ref);
 	}
-	m_LuaState = NULL;
+	m_LuaState = nullptr;
 	m_Ref = LUA_REFNIL;
 }
 
diff --git a/src/Bindings/LuaState.h b/src/Bindings/LuaState.h
index 899228a66..d1e9923b4 100644
--- a/src/Bindings/LuaState.h
+++ b/src/Bindings/LuaState.h
@@ -164,7 +164,7 @@ public:
 	void Detach(void);
 	
 	/** Returns true if the m_LuaState is valid */
-	bool IsValid(void) const { return (m_LuaState != NULL); }
+	bool IsValid(void) const { return (m_LuaState != nullptr); }
 	
 	/** Adds the specified path to package.<a_PathVariable> */
 	void AddPackagePath(const AString & a_PathVariable, const AString & a_Path);
@@ -318,10 +318,10 @@ public:
 	void ToString(int a_StackPos, AString & a_String);
 
 	/** Logs all the elements' types on the API stack, with an optional header for the listing. */
-	void LogStack(const char * a_Header = NULL);
+	void LogStack(const char * a_Header = nullptr);
 	
 	/** Logs all the elements' types on the API stack, with an optional header for the listing. */
-	static void LogStack(lua_State * a_LuaState, const char * a_Header = NULL);
+	static void LogStack(lua_State * a_LuaState, const char * a_Header = nullptr);
 	
 protected:
 
diff --git a/src/Bindings/LuaWindow.cpp b/src/Bindings/LuaWindow.cpp
index c4d03b86b..35730878d 100644
--- a/src/Bindings/LuaWindow.cpp
+++ b/src/Bindings/LuaWindow.cpp
@@ -18,7 +18,7 @@
 cLuaWindow::cLuaWindow(cWindow::WindowType a_WindowType, int a_SlotsX, int a_SlotsY, const AString & a_Title) :
 	super(a_WindowType, a_Title),
 	m_Contents(a_SlotsX, a_SlotsY),
-	m_Plugin(NULL),
+	m_Plugin(nullptr),
 	m_LuaRef(LUA_REFNIL),
 	m_OnClosingFnRef(LUA_REFNIL),
 	m_OnSlotChangedFnRef(LUA_REFNIL)
@@ -70,7 +70,7 @@ cLuaWindow::~cLuaWindow()
 void cLuaWindow::SetLuaRef(cPluginLua * a_Plugin, int a_LuaRef)
 {
 	// Either m_Plugin is not set or equal to the passed plugin; only one plugin can use one cLuaWindow object
-	ASSERT((m_Plugin == NULL) || (m_Plugin == a_Plugin));
+	ASSERT((m_Plugin == nullptr) || (m_Plugin == a_Plugin));
 	ASSERT(m_LuaRef == LUA_REFNIL);
 	m_Plugin = a_Plugin;
 	m_LuaRef = a_LuaRef;
@@ -82,7 +82,7 @@ void cLuaWindow::SetLuaRef(cPluginLua * a_Plugin, int a_LuaRef)
 
 bool cLuaWindow::IsLuaReferenced(void) const
 {
-	return ((m_Plugin != NULL) && (m_LuaRef != LUA_REFNIL));
+	return ((m_Plugin != nullptr) && (m_LuaRef != LUA_REFNIL));
 }
 
 
@@ -92,7 +92,7 @@ bool cLuaWindow::IsLuaReferenced(void) const
 void cLuaWindow::SetOnClosing(cPluginLua * a_Plugin, int a_FnRef)
 {
 	// Either m_Plugin is not set or equal to the passed plugin; only one plugin can use one cLuaWindow object
-	ASSERT((m_Plugin == NULL) || (m_Plugin == a_Plugin));
+	ASSERT((m_Plugin == nullptr) || (m_Plugin == a_Plugin));
 	
 	// If there already was a function, unreference it first
 	if (m_OnClosingFnRef != LUA_REFNIL)
@@ -112,7 +112,7 @@ void cLuaWindow::SetOnClosing(cPluginLua * a_Plugin, int a_FnRef)
 void cLuaWindow::SetOnSlotChanged(cPluginLua * a_Plugin, int a_FnRef)
 {
 	// Either m_Plugin is not set or equal to the passed plugin; only one plugin can use one cLuaWindow object
-	ASSERT((m_Plugin == NULL) || (m_Plugin == a_Plugin));
+	ASSERT((m_Plugin == nullptr) || (m_Plugin == a_Plugin));
 	
 	// If there already was a function, unreference it first
 	if (m_OnSlotChangedFnRef != LUA_REFNIL)
@@ -134,7 +134,7 @@ bool cLuaWindow::ClosedByPlayer(cPlayer & a_Player, bool a_CanRefuse)
 	// First notify the plugin through the registered callback:
 	if (m_OnClosingFnRef != LUA_REFNIL)
 	{
-		ASSERT(m_Plugin != NULL);
+		ASSERT(m_Plugin != nullptr);
 		if (m_Plugin->CallbackWindowClosing(m_OnClosingFnRef, *this, a_Player, a_CanRefuse))
 		{
 			// The callback disagrees (the higher levels check the CanRefuse flag compliance)
@@ -153,7 +153,7 @@ void cLuaWindow::Destroy(void)
 {
 	super::Destroy();
 	
-	if ((m_LuaRef != LUA_REFNIL) && (m_Plugin != NULL))
+	if ((m_LuaRef != LUA_REFNIL) && (m_Plugin != nullptr))
 	{
 		// The object is referenced by Lua, un-reference it
 		m_Plugin->Unreference(m_LuaRef);
diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp
index 0558533ce..a4a5d79b4 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -145,13 +145,13 @@ static AString GetLogMessage(lua_State * tolua_S)
 	tolua_Error err;
 	if (tolua_isusertype(tolua_S, 1, "cCompositeChat", false, &err))
 	{
-		return ((cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL))->ExtractText();
+		return ((cCompositeChat *)tolua_tousertype(tolua_S, 1, nullptr))->ExtractText();
 	}
 	else
 	{
 		size_t len = 0;
 		const char * str = lua_tolstring(tolua_S, 1, &len);
-		if (str != NULL)
+		if (str != nullptr)
 		{
 			return AString(str, len);
 		}
@@ -170,7 +170,7 @@ static int tolua_LOG(lua_State * tolua_S)
 	tolua_Error err;
 	if (tolua_isusertype(tolua_S, 1, "cCompositeChat", false, &err))
 	{
-		LogLevel = cCompositeChat::MessageTypeToLogLevel(((cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL))->GetMessageType());
+		LogLevel = cCompositeChat::MessageTypeToLogLevel(((cCompositeChat *)tolua_tousertype(tolua_S, 1, nullptr))->GetMessageType());
 	}
 	
 	// Log the message:
@@ -264,7 +264,7 @@ static cPluginLua * GetLuaPlugin(lua_State * L)
 	{
 		LOGWARNING("%s: cannot get plugin instance, what have you done to my Lua state?", __FUNCTION__);
 		lua_pop(L, 1);
-		return NULL;
+		return nullptr;
 	}
 	cPluginLua * Plugin = (cPluginLua *)lua_topointer(L, -1);
 	lua_pop(L, 1);
@@ -312,10 +312,10 @@ static int tolua_DoWith(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 2 or 3 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, nullptr);
 
 	const char * ItemName = tolua_tocppstring(tolua_S, 2, "");
-	if ((ItemName == NULL) || (ItemName[0] == 0))
+	if ((ItemName == nullptr) || (ItemName[0] == 0))
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a non-empty string for parameter #1", NumArgs);
 	}
@@ -406,7 +406,7 @@ static int tolua_DoWithID(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 2 or 3 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)tolua_tousertype(tolua_S, 1, NULL);
+	Ty1 * self = (Ty1 *)tolua_tousertype(tolua_S, 1, nullptr);
 
 	int ItemID = (int)tolua_tonumber(tolua_S, 2, 0);
 	if (!lua_isfunction(tolua_S, 3))
@@ -496,7 +496,7 @@ static int tolua_DoWithXYZ(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 4 or 5 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, nullptr);
 	if (!lua_isnumber(tolua_S, 2) || !lua_isnumber(tolua_S, 3) || !lua_isnumber(tolua_S, 4))
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a number for parameters #1, #2 and #3");
@@ -591,7 +591,7 @@ static int tolua_ForEachInChunk(lua_State * tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 3 or 4 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, nullptr);
 	if (!lua_isnumber(tolua_S, 2) || !lua_isnumber(tolua_S, 3))
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a number for parameters #1 and #2");
@@ -694,10 +694,10 @@ static int tolua_ForEachInBox(lua_State * tolua_S)
 	}
 
 	// Get the params:
-	Ty1 * Self = NULL;
-	cBoundingBox * Box = NULL;
+	Ty1 * Self = nullptr;
+	cBoundingBox * Box = nullptr;
 	L.GetStackValues(1, Self, Box);
-	if ((Self == NULL) || (Box == NULL))
+	if ((Self == nullptr) || (Box == nullptr))
 	{
 		LOGWARNING("Invalid world (%p) or boundingbox (%p)", Self, Box);
 		L.LogStackTrace();
@@ -760,8 +760,8 @@ static int tolua_ForEach(lua_State * tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 1 or 2 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	Ty1 * self = (Ty1 *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
 	}
@@ -857,14 +857,14 @@ static int tolua_cWorld_GetBlockInfo(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, nullptr);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
 		#ifndef TOLUA_RELEASE
-		if (self == NULL)
+		if (self == nullptr)
 		{
-			tolua_error(tolua_S, "invalid 'self' in function 'GetBlockInfo'", NULL);
+			tolua_error(tolua_S, "invalid 'self' in function 'GetBlockInfo'", nullptr);
 		}
 		#endif
 		{
@@ -912,14 +912,14 @@ static int tolua_cWorld_GetBlockTypeMeta(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, nullptr);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
 		#ifndef TOLUA_RELEASE
-		if (self == NULL)
+		if (self == nullptr)
 		{
-			tolua_error(tolua_S, "invalid 'self' in function 'GetBlockTypeMeta'", NULL);
+			tolua_error(tolua_S, "invalid 'self' in function 'GetBlockTypeMeta'", nullptr);
 		}
 		#endif
 		{
@@ -964,14 +964,14 @@ static int tolua_cWorld_GetSignLines(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, nullptr);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
 		#ifndef TOLUA_RELEASE
-		if (self == NULL)
+		if (self == nullptr)
 		{
-			tolua_error(tolua_S, "invalid 'self' in function 'GetSignLines'", NULL);
+			tolua_error(tolua_S, "invalid 'self' in function 'GetSignLines'", nullptr);
 		}
 		#endif
 		{
@@ -1022,7 +1022,7 @@ static int tolua_cWorld_SetSignLines(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, nullptr);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
@@ -1030,11 +1030,11 @@ static int tolua_cWorld_SetSignLines(lua_State * tolua_S)
 		const AString Line2 =            tolua_tocppstring(tolua_S, 6, 0);
 		const AString Line3 =            tolua_tocppstring(tolua_S, 7, 0);
 		const AString Line4 =            tolua_tocppstring(tolua_S, 8, 0);
-		cPlayer * Player    = (cPlayer *)tolua_tousertype (tolua_S, 9, NULL);
+		cPlayer * Player    = (cPlayer *)tolua_tousertype (tolua_S, 9, nullptr);
 		#ifndef TOLUA_RELEASE
-		if (self == NULL)
+		if (self == nullptr)
 		{
-			tolua_error(tolua_S, "invalid 'self' in function 'SetSignLines' / 'UpdateSign'", NULL);
+			tolua_error(tolua_S, "invalid 'self' in function 'SetSignLines' / 'UpdateSign'", nullptr);
 		}
 		#endif
 		{
@@ -1071,13 +1071,13 @@ static int tolua_cWorld_TryGetHeight(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, nullptr);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		#ifndef TOLUA_RELEASE
-		if (self == NULL)
+		if (self == nullptr)
 		{
-			tolua_error(tolua_S, "Invalid 'self' in function 'TryGetHeight'", NULL);
+			tolua_error(tolua_S, "Invalid 'self' in function 'TryGetHeight'", nullptr);
 		}
 		#endif
 		{
@@ -1136,15 +1136,15 @@ static int tolua_cWorld_QueueTask(lua_State * tolua_S)
 	
 	// Retrieve the cPlugin from the LuaState:
 	cPluginLua * Plugin = GetLuaPlugin(tolua_S);
-	if (Plugin == NULL)
+	if (Plugin == nullptr)
 	{
 		// An error message has been already printed in GetLuaPlugin()
 		return 0;
 	}
 
 	// Retrieve the args:
-	cWorld * self = (cWorld *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cWorld * self = (cWorld *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
 	}
@@ -1200,7 +1200,7 @@ static int tolua_cWorld_ScheduleTask(lua_State * tolua_S)
 	
 	// Retrieve the cPlugin from the LuaState:
 	cPluginLua * Plugin = GetLuaPlugin(tolua_S);
-	if (Plugin == NULL)
+	if (Plugin == nullptr)
 	{
 		// An error message has been already printed in GetLuaPlugin()
 		return 0;
@@ -1216,8 +1216,8 @@ static int tolua_cWorld_ScheduleTask(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cWorld * World = (cWorld *)tolua_tousertype(tolua_S, 1, NULL);
-	if (World == NULL)
+	cWorld * World = (cWorld *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (World == nullptr)
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
 	}
@@ -1241,7 +1241,7 @@ static int tolua_cWorld_ScheduleTask(lua_State * tolua_S)
 
 static int tolua_cPluginManager_GetAllPlugins(lua_State * tolua_S)
 {
-	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, NULL);
+	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, nullptr);
 
 	const cPluginManager::PluginMap & AllPlugins = self->GetAllPlugins();
 
@@ -1252,7 +1252,7 @@ static int tolua_cPluginManager_GetAllPlugins(lua_State * tolua_S)
 	{
 		const cPlugin* Plugin = iter->second;
 		tolua_pushstring(tolua_S, iter->first.c_str());
-		if (Plugin != NULL)
+		if (Plugin != nullptr)
 		{
 			tolua_pushusertype(tolua_S, (void *)Plugin, "const cPlugin");
 		}
@@ -1274,7 +1274,7 @@ static int tolua_cPluginManager_GetAllPlugins(lua_State * tolua_S)
 static int tolua_cPluginManager_GetCurrentPlugin(lua_State * S)
 {
 	cPluginLua * Plugin = GetLuaPlugin(S);
-	if (Plugin == NULL)
+	if (Plugin == nullptr)
 	{
 		// An error message has already been printed in GetLuaPlugin()
 		return 0;
@@ -1305,7 +1305,7 @@ static int tolua_cPluginManager_AddHook_FnRef(cPluginManager * a_PluginManager,
 	
 	// Retrieve the cPlugin from the LuaState:
 	cPluginLua * Plugin = GetLuaPlugin(S);
-	if (Plugin == NULL)
+	if (Plugin == nullptr)
 	{
 		// An error message has been already printed in GetLuaPlugin()
 		return 0;
@@ -1344,8 +1344,8 @@ static int tolua_cPluginManager_AddHook_DefFn(cPluginManager * a_PluginManager,
 	// The arg types have already been checked
 	
 	// Retrieve and check the cPlugin parameter
-	cPluginLua * Plugin = (cPluginLua *)tolua_tousertype(S, a_ParamIdx, NULL);
-	if (Plugin == NULL)
+	cPluginLua * Plugin = (cPluginLua *)tolua_tousertype(S, a_ParamIdx, nullptr);
+	if (Plugin == nullptr)
 	{
 		LOGWARNING("cPluginManager.AddHook(): Invalid Plugin parameter, expected a valid cPlugin object. Hook not added");
 		S.LogStackTrace();
@@ -1370,7 +1370,7 @@ static int tolua_cPluginManager_AddHook_DefFn(cPluginManager * a_PluginManager,
 	
 	// Get the standard name for the callback function:
 	const char * FnName = cPluginLua::GetHookFnName(HookType);
-	if (FnName == NULL)
+	if (FnName == nullptr)
 	{
 		LOGWARNING("cPluginManager.AddHook(): Unknown hook type (%d). Hook not added.", HookType);
 		S.LogStackTrace();
@@ -1417,8 +1417,8 @@ static int tolua_cPluginManager_AddHook(lua_State * tolua_S)
 	if (tolua_isusertype(S, 1, "cPluginManager", 0, &err))
 	{
 		// Style 2 or 3, retrieve the PlgMgr instance
-		PlgMgr = (cPluginManager *)tolua_tousertype(S, 1, NULL);
-		if (PlgMgr == NULL)
+		PlgMgr = (cPluginManager *)tolua_tousertype(S, 1, nullptr);
+		if (PlgMgr == nullptr)
 		{
 			LOGWARNING("Malformed plugin, use cPluginManager.AddHook(HOOK_TYPE, CallbackFunction). Fixing the call for you.");
 			S.LogStackTrace();
@@ -1465,8 +1465,8 @@ static int tolua_cPluginManager_ForEachCommand(lua_State * tolua_S)
 		return 0;
 	}
 
-	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
 		LOGWARN("Error in function call 'ForEachCommand': Not called on an object instance");
 		return 0;
@@ -1542,8 +1542,8 @@ static int tolua_cPluginManager_ForEachConsoleCommand(lua_State * tolua_S)
 		return 0;
 	}
 
-	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
 		LOGWARN("Error in function call 'ForEachConsoleCommand': Not called on an object instance");
 		return 0;
@@ -1617,7 +1617,7 @@ static int tolua_cPluginManager_BindCommand(lua_State * L)
 		cPluginManager.BindCommand(Command, Permission, Function, HelpString)  -- without the "self" param
 	*/
 	cPluginLua * Plugin = GetLuaPlugin(L);
-	if (Plugin == NULL)
+	if (Plugin == nullptr)
 	{
 		return 0;
 	}
@@ -1687,7 +1687,7 @@ static int tolua_cPluginManager_BindConsoleCommand(lua_State * L)
 	
 	// Get the plugin identification out of LuaState:
 	cPluginLua * Plugin = GetLuaPlugin(L);
-	if (Plugin == NULL)
+	if (Plugin == nullptr)
 	{
 		return 0;
 	}
@@ -1775,7 +1775,7 @@ static int tolua_cPluginManager_CallPlugin(lua_State * tolua_S)
 	
 	// If requesting calling the current plugin, refuse:
 	cPluginLua * ThisPlugin = GetLuaPlugin(L);
-	if (ThisPlugin == NULL)
+	if (ThisPlugin == nullptr)
 	{
 		return 0;
 	}
@@ -1843,14 +1843,14 @@ static int tolua_cWorld_ChunkStay(lua_State * tolua_S)
 	}
 	
 	cPluginLua * Plugin = GetLuaPlugin(tolua_S);
-	if (Plugin == NULL)
+	if (Plugin == nullptr)
 	{
 		return 0;
 	}
 	
 	// Read the params:
-	cWorld * World = (cWorld *)tolua_tousertype(tolua_S, 1, NULL);
-	if (World == NULL)
+	cWorld * World = (cWorld *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (World == nullptr)
 	{
 		LOGWARNING("World:ChunkStay(): invalid world parameter");
 		L.LogStackTrace();
@@ -1862,7 +1862,7 @@ static int tolua_cWorld_ChunkStay(lua_State * tolua_S)
 	if (!ChunkStay->AddChunks(2))
 	{
 		delete ChunkStay;
-		ChunkStay = NULL;
+		ChunkStay = nullptr;
 		return 0;
 	}
 
@@ -1889,8 +1889,8 @@ static int tolua_cPlayer_GetPermissions(lua_State * tolua_S)
 	}
 
 	// Get the params:
-	cPlayer * self = (cPlayer *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cPlayer * self = (cPlayer *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
 		LOGWARNING("%s: invalid self (%p)", __FUNCTION__, self);
 		return 0;
@@ -1911,15 +1911,15 @@ static int tolua_cPlayer_OpenWindow(lua_State * tolua_S)
 
 	// Retrieve the plugin instance from the Lua state
 	cPluginLua * Plugin = GetLuaPlugin(tolua_S);
-	if (Plugin == NULL)
+	if (Plugin == nullptr)
 	{
 		return 0;
 	}
 
 	// Get the parameters:
-	cPlayer * self = (cPlayer *)tolua_tousertype(tolua_S, 1, NULL);
-	cWindow * wnd  = (cWindow *)tolua_tousertype(tolua_S, 2, NULL);
-	if ((self == NULL) || (wnd == NULL))
+	cPlayer * self = (cPlayer *)tolua_tousertype(tolua_S, 1, nullptr);
+	cWindow * wnd  = (cWindow *)tolua_tousertype(tolua_S, 2, nullptr);
+	if ((self == nullptr) || (wnd == nullptr))
 	{
 		LOGWARNING("%s: invalid self (%p) or wnd (%p)", __FUNCTION__, self, wnd);
 		return 0;
@@ -1992,15 +1992,15 @@ static int tolua_SetObjectCallback(lua_State * tolua_S)
 
 	// Retrieve the plugin instance from the Lua state
 	cPluginLua * Plugin = GetLuaPlugin(tolua_S);
-	if (Plugin == NULL)
+	if (Plugin == nullptr)
 	{
 		// Warning message has already been printed by GetLuaPlugin(), bail out silently
 		return 0;
 	}
 
 	// Get the parameters - self and the function reference:
-	OBJTYPE * self = (OBJTYPE *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	OBJTYPE * self = (OBJTYPE *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
 		LOGWARNING("%s: invalid self (%p)", __FUNCTION__, self);
 		return 0;
@@ -2023,7 +2023,7 @@ static int tolua_SetObjectCallback(lua_State * tolua_S)
 
 static int tolua_cPluginLua_AddWebTab(lua_State * tolua_S)
 {
-	cPluginLua * self = (cPluginLua *)tolua_tousertype(tolua_S, 1, NULL);
+	cPluginLua * self = (cPluginLua *)tolua_tousertype(tolua_S, 1, nullptr);
 
 	tolua_Error tolua_err;
 	tolua_err.array = 0;
@@ -2067,7 +2067,7 @@ static int tolua_cPluginLua_AddWebTab(lua_State * tolua_S)
 
 static int tolua_cPluginLua_AddTab(lua_State* tolua_S)
 {
-	cPluginLua * self = (cPluginLua *) tolua_tousertype(tolua_S, 1, NULL);
+	cPluginLua * self = (cPluginLua *) tolua_tousertype(tolua_S, 1, nullptr);
 	LOGWARN("WARNING: Using deprecated function AddTab()! Use AddWebTab() instead. (plugin \"%s\" in folder \"%s\")",
 		self->GetName().c_str(), self->GetDirectory().c_str()
 	);
@@ -2087,7 +2087,7 @@ static int tolua_cPlugin_Call(lua_State * tolua_S)
 	L.LogStackTrace();
 	
 	// Retrieve the params: plugin and the function name to call
-	cPluginLua * TargetPlugin = (cPluginLua *) tolua_tousertype(tolua_S, 1, NULL);
+	cPluginLua * TargetPlugin = (cPluginLua *) tolua_tousertype(tolua_S, 1, nullptr);
 	AString FunctionName = tolua_tostring(tolua_S, 2, "");
 	
 	// Call the function:
@@ -2142,7 +2142,7 @@ static int tolua_push_StringStringMap(lua_State* tolua_S, std::map< std::string,
 
 static int tolua_get_HTTPRequest_Params(lua_State* tolua_S)
 {
-	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, NULL);
+	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, nullptr);
 	return tolua_push_StringStringMap(tolua_S, self->Params);
 }
 
@@ -2152,7 +2152,7 @@ static int tolua_get_HTTPRequest_Params(lua_State* tolua_S)
 
 static int tolua_get_HTTPRequest_PostParams(lua_State* tolua_S)
 {
-	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, NULL);
+	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, nullptr);
 	return tolua_push_StringStringMap(tolua_S, self->PostParams);
 }
 
@@ -2162,7 +2162,7 @@ static int tolua_get_HTTPRequest_PostParams(lua_State* tolua_S)
 
 static int tolua_get_HTTPRequest_FormData(lua_State* tolua_S)
 {
-	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, NULL);
+	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, nullptr);
 	std::map< std::string, HTTPFormData >& FormData = self->FormData;
 
 	lua_newtable(tolua_S);
@@ -2185,7 +2185,7 @@ static int tolua_get_HTTPRequest_FormData(lua_State* tolua_S)
 
 static int tolua_cWebAdmin_GetPlugins(lua_State * tolua_S)
 {
-	cWebAdmin * self = (cWebAdmin *)tolua_tousertype(tolua_S, 1, NULL);
+	cWebAdmin * self = (cWebAdmin *)tolua_tousertype(tolua_S, 1, nullptr);
 
 	const cWebAdmin::PluginList & AllPlugins = self->GetPlugins();
 
@@ -2266,7 +2266,7 @@ static int tolua_AllToLua_cWebAdmin_GetURLEncodedString(lua_State * tolua_S)
 
 static int tolua_cWebPlugin_GetTabNames(lua_State * tolua_S)
 {
-	cWebPlugin* self = (cWebPlugin*)  tolua_tousertype(tolua_S, 1, NULL);
+	cWebPlugin* self = (cWebPlugin*)  tolua_tousertype(tolua_S, 1, nullptr);
 
 	const cWebPlugin::TabNameList & TabNames = self->GetTabNames();
 
@@ -2302,8 +2302,8 @@ static int tolua_cClientHandle_SendPluginMessage(lua_State * L)
 	{
 		return 0;
 	}
-	cClientHandle * Client = (cClientHandle *)tolua_tousertype(L, 1, NULL);
-	if (Client == NULL)
+	cClientHandle * Client = (cClientHandle *)tolua_tousertype(L, 1, nullptr);
+	if (Client == nullptr)
 	{
 		LOGWARNING("ClientHandle is nil in cClientHandle:SendPluginMessage()");
 		S.LogStackTrace();
@@ -2548,11 +2548,11 @@ static int Lua_ItemGrid_GetSlotCoords(lua_State * L)
 	}
 
 	{
-		const cItemGrid * self = (const cItemGrid *)tolua_tousertype(L, 1, NULL);
+		const cItemGrid * self = (const cItemGrid *)tolua_tousertype(L, 1, nullptr);
 		int SlotNum = (int)tolua_tonumber(L, 2, 0);
-		if (self == NULL)
+		if (self == nullptr)
 		{
-			tolua_error(L, "invalid 'self' in function 'cItemGrid:GetSlotCoords'", NULL);
+			tolua_error(L, "invalid 'self' in function 'cItemGrid:GetSlotCoords'", nullptr);
 			return 0;
 		}
 		int X, Y;
@@ -2689,7 +2689,7 @@ static int tolua_cLineBlockTracer_Trace(lua_State * tolua_S)
 	}
 
 	// Trace:
-	cWorld * World = (cWorld *)tolua_tousertype(L, idx, NULL);
+	cWorld * World = (cWorld *)tolua_tousertype(L, idx, nullptr);
 	cLuaBlockTracerCallbacks Callbacks(L, idx + 1);
 	double StartX = tolua_tonumber(L, idx + 2, 0);
 	double StartY = tolua_tonumber(L, idx + 3, 0);
@@ -2719,8 +2719,8 @@ static int tolua_cRoot_GetFurnaceRecipe(lua_State * tolua_S)
 	}
 	
 	// Check the input param:
-	cItem * Input = (cItem *)tolua_tousertype(L, 2, NULL);
-	if (Input == NULL)
+	cItem * Input = (cItem *)tolua_tousertype(L, 2, nullptr);
+	if (Input == nullptr)
 	{
 		LOGWARNING("cRoot:GetFurnaceRecipe: the Input parameter is nil or missing.");
 		return 0;
@@ -2729,7 +2729,7 @@ static int tolua_cRoot_GetFurnaceRecipe(lua_State * tolua_S)
 	// Get the recipe for the input
 	cFurnaceRecipe * FR = cRoot::Get()->GetFurnaceRecipe();
 	const cFurnaceRecipe::cRecipe * Recipe = FR->GetRecipeFrom(*Input);
-	if (Recipe == NULL)
+	if (Recipe == nullptr)
 	{
 		// There is no such furnace recipe for this input, return no value
 		return 0;
@@ -2760,10 +2760,10 @@ static int tolua_cHopperEntity_GetOutputBlockPos(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cHopperEntity * self = (cHopperEntity *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cHopperEntity * self = (cHopperEntity *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cHopperEntity::GetOutputBlockPos()'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cHopperEntity::GetOutputBlockPos()'", nullptr);
 		return 0;
 	}
 
@@ -2800,10 +2800,10 @@ static int tolua_cBlockArea_GetBlockTypeMeta(lua_State * tolua_S)
 		return 0;
 	}
 	
-	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetRelBlockTypeMeta'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetRelBlockTypeMeta'", nullptr);
 		return 0;
 	}
 	int BlockX = (int)tolua_tonumber(tolua_S, 2, 0);
@@ -2834,10 +2834,10 @@ static int tolua_cBlockArea_GetOrigin(lua_State * tolua_S)
 		return 0;
 	}
 	
-	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetOrigin'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetOrigin'", nullptr);
 		return 0;
 	}
 	
@@ -2866,10 +2866,10 @@ static int tolua_cBlockArea_GetRelBlockTypeMeta(lua_State * tolua_S)
 		return 0;
 	}
 	
-	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetRelBlockTypeMeta'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetRelBlockTypeMeta'", nullptr);
 		return 0;
 	}
 	int BlockX = (int)tolua_tonumber(tolua_S, 2, 0);
@@ -2900,10 +2900,10 @@ static int tolua_cBlockArea_GetSize(lua_State * tolua_S)
 		return 0;
 	}
 	
-	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetSize'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetSize'", nullptr);
 		return 0;
 	}
 	
@@ -2931,10 +2931,10 @@ static int tolua_cBlockArea_GetCoordRange(lua_State * tolua_S)
 		return 0;
 	}
 	
-	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetSize'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetSize'", nullptr);
 		return 0;
 	}
 	
@@ -2962,10 +2962,10 @@ static int tolua_cBlockArea_LoadFromSchematicFile(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::LoadFromSchematicFile'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::LoadFromSchematicFile'", nullptr);
 		return 0;
 	}
 
@@ -2992,10 +2992,10 @@ static int tolua_cBlockArea_LoadFromSchematicString(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::LoadFromSchematicFile'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::LoadFromSchematicFile'", nullptr);
 		return 0;
 	}
 
@@ -3023,10 +3023,10 @@ static int tolua_cBlockArea_SaveToSchematicFile(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::SaveToSchematicFile'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::SaveToSchematicFile'", nullptr);
 		return 0;
 	}
 	AString Filename = tolua_tostring(tolua_S, 2, 0);
@@ -3051,10 +3051,10 @@ static int tolua_cBlockArea_SaveToSchematicString(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::SaveToSchematicFile'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::SaveToSchematicFile'", nullptr);
 		return 0;
 	}
 	
@@ -3085,10 +3085,10 @@ static int tolua_cCompositeChat_AddRunCommandPart(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddRunCommandPart'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddRunCommandPart'", nullptr);
 		return 0;
 	}
 	
@@ -3122,10 +3122,10 @@ static int tolua_cCompositeChat_AddSuggestCommandPart(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddSuggestCommandPart'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddSuggestCommandPart'", nullptr);
 		return 0;
 	}
 	
@@ -3159,10 +3159,10 @@ static int tolua_cCompositeChat_AddTextPart(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddTextPart'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddTextPart'", nullptr);
 		return 0;
 	}
 	
@@ -3195,10 +3195,10 @@ static int tolua_cCompositeChat_AddUrlPart(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddUrlPart'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddUrlPart'", nullptr);
 		return 0;
 	}
 	
@@ -3232,10 +3232,10 @@ static int tolua_cCompositeChat_ParseText(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:ParseText'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:ParseText'", nullptr);
 		return 0;
 	}
 	
@@ -3267,10 +3267,10 @@ static int tolua_cCompositeChat_SetMessageType(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:SetMessageType'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:SetMessageType'", nullptr);
 		return 0;
 	}
 	
@@ -3299,10 +3299,10 @@ static int tolua_cCompositeChat_UnderlineUrls(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
-	if (self == NULL)
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
 	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:UnderlineUrls'", NULL);
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:UnderlineUrls'", nullptr);
 		return 0;
 	}
 	
@@ -3320,7 +3320,7 @@ static int tolua_cCompositeChat_UnderlineUrls(lua_State * tolua_S)
 
 void ManualBindings::Bind(lua_State * tolua_S)
 {
-	tolua_beginmodule(tolua_S, NULL);
+	tolua_beginmodule(tolua_S, nullptr);
 		tolua_function(tolua_S, "Clamp",              tolua_Clamp);
 		tolua_function(tolua_S, "StringSplit",        tolua_StringSplit);
 		tolua_function(tolua_S, "StringSplitAndTrim", tolua_StringSplitAndTrim);
@@ -3447,7 +3447,7 @@ void ManualBindings::Bind(lua_State * tolua_S)
 			tolua_function(tolua_S, "AddWebTab", tolua_cPluginLua_AddWebTab);
 		tolua_endmodule(tolua_S);
 
-		tolua_cclass(tolua_S, "HTTPRequest", "HTTPRequest", "", NULL);
+		tolua_cclass(tolua_S, "HTTPRequest", "HTTPRequest", "", nullptr);
 		tolua_beginmodule(tolua_S, "HTTPRequest");
 			// tolua_variable(tolua_S, "Method", tolua_get_HTTPRequest_Method, tolua_set_HTTPRequest_Method);
 			// tolua_variable(tolua_S, "Path", tolua_get_HTTPRequest_Path, tolua_set_HTTPRequest_Path);
diff --git a/src/Bindings/ManualBindings_RankManager.cpp b/src/Bindings/ManualBindings_RankManager.cpp
index 66174bf86..fa1b88b6a 100644
--- a/src/Bindings/ManualBindings_RankManager.cpp
+++ b/src/Bindings/ManualBindings_RankManager.cpp
@@ -1044,7 +1044,7 @@ void ManualBindings::BindRankManager(lua_State * tolua_S)
 {
 	// Create the cRankManager class in the API:
 	tolua_usertype(tolua_S, "cRankManager");
-	tolua_cclass(tolua_S, "cRankManager", "cRankManager", "", NULL);
+	tolua_cclass(tolua_S, "cRankManager", "cRankManager", "", nullptr);
 	
 	// Fill in the functions (alpha-sorted):
 	tolua_beginmodule(tolua_S, "cRankManager");
diff --git a/src/Bindings/PluginLua.cpp b/src/Bindings/PluginLua.cpp
index eec31e8a6..391d8bcbe 100644
--- a/src/Bindings/PluginLua.cpp
+++ b/src/Bindings/PluginLua.cpp
@@ -1487,7 +1487,7 @@ void cPluginLua::ClearCommands(void)
 	cCSLock Lock(m_CriticalSection);
 
 	// Unreference the bound functions so that Lua can GC them
-	if (m_LuaState != NULL)
+	if (m_LuaState != nullptr)
 	{
 		for (CommandMap::iterator itr = m_Commands.begin(), end = m_Commands.end(); itr != end; ++itr)
 		{
@@ -1506,7 +1506,7 @@ void cPluginLua::ClearConsoleCommands(void)
 	cCSLock Lock(m_CriticalSection);
 
 	// Unreference the bound functions so that Lua can GC them
-	if (m_LuaState != NULL)
+	if (m_LuaState != nullptr)
 	{
 		for (CommandMap::iterator itr = m_ConsoleCommands.begin(), end = m_ConsoleCommands.end(); itr != end; ++itr)
 		{
@@ -1523,7 +1523,7 @@ void cPluginLua::ClearConsoleCommands(void)
 bool cPluginLua::CanAddOldStyleHook(int a_HookType)
 {
 	const char * FnName = GetHookFnName(a_HookType);
-	if (FnName == NULL)
+	if (FnName == nullptr)
 	{
 		// Unknown hook ID
 		LOGWARNING("Plugin %s wants to add an unknown hook ID (%d). The plugin need not work properly.",
@@ -1614,7 +1614,7 @@ const char * cPluginLua::GetHookFnName(int a_HookType)
 	}  // switch (a_Hook)
 	LOGWARNING("Requested name of an unknown hook type function: %d (max is %d)", a_HookType, cPluginManager::HOOK_MAX);
 	ASSERT(!"Unknown hook requested!");
-	return NULL;
+	return nullptr;
 }
 
 
@@ -1627,12 +1627,12 @@ bool cPluginLua::AddHookRef(int a_HookType, int a_FnRefIdx)
 	
 	// Check if the function reference is valid:
 	cLuaState::cRef * Ref = new cLuaState::cRef(m_LuaState, a_FnRefIdx);
-	if ((Ref == NULL) || !Ref->IsValid())
+	if ((Ref == nullptr) || !Ref->IsValid())
 	{
 		LOGWARNING("Plugin %s tried to add a hook %d with bad handler function.", GetName().c_str(), a_HookType);
 		m_LuaState.LogStackTrace();
 		delete Ref;
-		Ref = NULL;
+		Ref = nullptr;
 		return false;
 	}
 	
@@ -1700,7 +1700,7 @@ AString cPluginLua::HandleWebRequest(const HTTPRequest * a_Request)
 		}
 	}
 
-	if (Tab != NULL)
+	if (Tab != nullptr)
 	{
 		AString Contents = Printf("WARNING: WebPlugin tab '%s' did not return a string!", Tab->Title.c_str());
 		if (!m_LuaState.Call(Tab->UserData, a_Request, cLuaState::Return, Contents))
diff --git a/src/Bindings/PluginManager.cpp b/src/Bindings/PluginManager.cpp
index 479e71951..e549aefa3 100644
--- a/src/Bindings/PluginManager.cpp
+++ b/src/Bindings/PluginManager.cpp
@@ -66,7 +66,7 @@ void cPluginManager::FindPlugins(void)
 	// First get a clean list of only the currently running plugins, we don't want to mess those up
 	for (PluginMap::iterator itr = m_Plugins.begin(); itr != m_Plugins.end();)
 	{
-		if (itr->second == NULL)
+		if (itr->second == nullptr)
 		{
 			PluginMap::iterator thiz = itr;
 			++thiz;
@@ -89,7 +89,7 @@ void cPluginManager::FindPlugins(void)
 		// Add plugin name/directory to the list
 		if (m_Plugins.find(*itr) == m_Plugins.end())
 		{
-			m_Plugins[*itr] = NULL;
+			m_Plugins[*itr] = nullptr;
 		}
 	}
 }
@@ -151,7 +151,7 @@ void cPluginManager::ReloadPluginsNow(cIniFile & a_SettingsIni)
 	// Remove invalid plugins from the PluginMap.
 	for (PluginMap::iterator itr = m_Plugins.begin(); itr != m_Plugins.end();)
 	{
-		if (itr->second == NULL)
+		if (itr->second == nullptr)
 		{
 			PluginMap::iterator thiz = itr;
 			++thiz;
@@ -1445,7 +1445,7 @@ cPluginManager::CommandResult cPluginManager::HandleCommand(cPlayer & a_Player,
 		return crNoPermission;
 	}
 
-	ASSERT(cmd->second.m_Plugin != NULL);
+	ASSERT(cmd->second.m_Plugin != nullptr);
 
 	if (!cmd->second.m_Plugin->HandleCommand(Split, a_Player))
 	{
@@ -1463,7 +1463,7 @@ cPlugin * cPluginManager::GetPlugin( const AString & a_Plugin) const
 {
 	for (PluginMap::const_iterator itr = m_Plugins.begin(); itr != m_Plugins.end(); ++itr)
 	{
-		if (itr->second == NULL) continue;
+		if (itr->second == nullptr) continue;
 		if (itr->second->GetName().compare(a_Plugin) == 0)
 		{
 			return itr->second;
@@ -1513,7 +1513,7 @@ bool cPluginManager::DisablePlugin(const AString & a_PluginName)
 	if (itr->first.compare(a_PluginName) == 0)  // _X 2013_02_01: wtf? Isn't this supposed to be what find() does?
 	{
 		m_DisablePluginList.push_back(itr->second);
-		itr->second = NULL;  // Get rid of this thing right away
+		itr->second = nullptr;  // Get rid of this thing right away
 		return true;
 	}
 	return false;
@@ -1558,12 +1558,12 @@ void cPluginManager::RemovePlugin(cPlugin * a_Plugin)
 	RemovePluginCommands(a_Plugin);
 	RemovePluginConsoleCommands(a_Plugin);
 	RemoveHooks(a_Plugin);
-	if (a_Plugin != NULL)
+	if (a_Plugin != nullptr)
 	{
 		a_Plugin->OnDisable();
 	}
 	delete a_Plugin;
-	a_Plugin = NULL;
+	a_Plugin = nullptr;
 }
 
 
@@ -1572,7 +1572,7 @@ void cPluginManager::RemovePlugin(cPlugin * a_Plugin)
 
 void cPluginManager::RemovePluginCommands(cPlugin * a_Plugin)
 {
-	if (a_Plugin != NULL)
+	if (a_Plugin != nullptr)
 	{
 		a_Plugin->ClearCommands();
 	}
@@ -1670,7 +1670,7 @@ cPluginManager::CommandResult cPluginManager::ForceExecuteCommand(cPlayer & a_Pl
 
 void cPluginManager::RemovePluginConsoleCommands(cPlugin * a_Plugin)
 {
-	if (a_Plugin != NULL)
+	if (a_Plugin != nullptr)
 	{
 		a_Plugin->ClearConsoleCommands();
 	}
@@ -1699,7 +1699,7 @@ bool cPluginManager::BindConsoleCommand(const AString & a_Command, cPlugin * a_P
 	CommandMap::iterator cmd = m_ConsoleCommands.find(a_Command);
 	if (cmd != m_ConsoleCommands.end())
 	{
-		if (cmd->second.m_Plugin == NULL)
+		if (cmd->second.m_Plugin == nullptr)
 		{
 			LOGWARNING("Console command \"%s\" is already bound internally by MCServer, cannot bind in plugin \"%s\".", a_Command.c_str(), a_Plugin->GetName().c_str());
 		}
@@ -1759,14 +1759,14 @@ bool cPluginManager::ExecuteConsoleCommand(const AStringVector & a_Split, cComma
 		return false;
 	}
 
-	if (cmd->second.m_Plugin == NULL)
+	if (cmd->second.m_Plugin == nullptr)
 	{
 		// This is a built-in command
 		return false;
 	}
 
 	// Ask plugins first if a command is okay to execute the console command:
-	if (CallHookExecuteCommand(NULL, a_Split))
+	if (CallHookExecuteCommand(nullptr, a_Split))
 	{
 		a_Output.Out("Command \"%s\" was stopped by the HOOK_EXECUTE_COMMAND hook", a_Split[0].c_str());
 		return false;
@@ -1788,7 +1788,7 @@ void cPluginManager::TabCompleteCommand(const AString & a_Text, AStringVector &
 			// Command name doesn't match
 			continue;
 		}
-		if ((a_Player != NULL) && !a_Player->HasPermission(itr->second.m_Permission))
+		if ((a_Player != nullptr) && !a_Player->HasPermission(itr->second.m_Permission))
 		{
 			// Player doesn't have permission for the command
 			continue;
@@ -1814,7 +1814,7 @@ bool cPluginManager::DoWithPlugin(const AString & a_PluginName, cPluginCallback
 {
 	// TODO: Implement locking for plugins
 	PluginMap::iterator itr = m_Plugins.find(a_PluginName);
-	if ((itr == m_Plugins.end()) || (itr->second == NULL))
+	if ((itr == m_Plugins.end()) || (itr->second == nullptr))
 	{
 		return false;
 	}
@@ -1848,7 +1848,7 @@ void cPluginManager::AddHook(cPlugin * a_Plugin, int a_Hook)
 {
 	if (!a_Plugin)
 	{
-		LOGWARN("Called cPluginManager::AddHook() with a_Plugin == NULL");
+		LOGWARN("Called cPluginManager::AddHook() with a_Plugin == nullptr");
 		return;
 	}
 	PluginList & Plugins = m_Hooks[a_Hook];
diff --git a/src/Bindings/PluginManager.h b/src/Bindings/PluginManager.h
index c69850be6..bc8c1f5e6 100644
--- a/src/Bindings/PluginManager.h
+++ b/src/Bindings/PluginManager.h
@@ -190,7 +190,7 @@ public:
 	bool CallHookCraftingNoRecipe         (cPlayer & a_Player, cCraftingGrid & a_Grid, cCraftingRecipe * a_Recipe);
 	bool CallHookDisconnect               (cClientHandle & a_Client, const AString & a_Reason);
 	bool CallHookEntityAddEffect          (cEntity & a_Entity, int a_EffectType, int a_EffectDurationTicks, int a_EffectIntensity, double a_DistanceModifier);
-	bool CallHookExecuteCommand           (cPlayer * a_Player, const AStringVector & a_Split);  // If a_Player == NULL, it is a console cmd
+	bool CallHookExecuteCommand           (cPlayer * a_Player, const AStringVector & a_Split);  // If a_Player == nullptr, it is a console cmd
 	bool CallHookExploded                 (cWorld & a_World, double a_ExplosionSize,   bool a_CanCauseFire,   double a_X, double a_Y, double a_Z, eExplosionSource a_Source, void * a_SourceData);
 	bool CallHookExploding                (cWorld & a_World, double & a_ExplosionSize, bool & a_CanCauseFire, double a_X, double a_Y, double a_Z, eExplosionSource a_Source, void * a_SourceData);
 	bool CallHookHandshake                (cClientHandle & a_ClientHandle, const AString & a_Username);
@@ -285,7 +285,7 @@ public:
 	bool ExecuteConsoleCommand(const AStringVector & a_Split, cCommandOutputCallback & a_Output);
 	
 	/** Appends all commands beginning with a_Text (case-insensitive) into a_Results.
-	If a_Player is not NULL, only commands for which the player has permissions are added.
+	If a_Player is not nullptr, only commands for which the player has permissions are added.
 	*/
 	void TabCompleteCommand(const AString & a_Text, AStringVector & a_Results, cPlayer * a_Player);
 	
diff --git a/src/Bindings/WebPlugin.cpp b/src/Bindings/WebPlugin.cpp
index eca1c74e6..5759b20e7 100644
--- a/src/Bindings/WebPlugin.cpp
+++ b/src/Bindings/WebPlugin.cpp
@@ -12,7 +12,7 @@
 cWebPlugin::cWebPlugin()
 {
 	cWebAdmin * WebAdmin = cRoot::Get()->GetWebAdmin();
-	if (WebAdmin != NULL)
+	if (WebAdmin != nullptr)
 	{
 		WebAdmin->AddPlugin(this);
 	}
@@ -25,7 +25,7 @@ cWebPlugin::cWebPlugin()
 cWebPlugin::~cWebPlugin()
 {
 	cWebAdmin * WebAdmin = cRoot::Get()->GetWebAdmin();
-	if (WebAdmin != NULL)
+	if (WebAdmin != nullptr)
 	{
 		WebAdmin->RemovePlugin(this);
 	}
@@ -65,7 +65,7 @@ std::pair< AString, AString > cWebPlugin::GetTabNameForRequest(const HTTPRequest
 
 	if (Split.size() > 1)
 	{
-		sWebPluginTab * Tab = NULL;
+		sWebPluginTab * Tab = nullptr;
 		if (Split.size() > 2)  // If we got the tab name, show that page
 		{
 			for (TabList::iterator itr = GetTabs().begin(); itr != GetTabs().end(); ++itr)
@@ -85,7 +85,7 @@ std::pair< AString, AString > cWebPlugin::GetTabNameForRequest(const HTTPRequest
 			}
 		}
 
-		if (Tab != NULL)
+		if (Tab != nullptr)
 		{
 			Names.first = Tab->Title;
 			Names.second = Tab->SafeTitle;
diff --git a/src/BlockArea.cpp b/src/BlockArea.cpp
index ba55528b8..4c3da0535 100644
--- a/src/BlockArea.cpp
+++ b/src/BlockArea.cpp
@@ -273,10 +273,10 @@ void MergeCombinatorMask(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE
 // cBlockArea:
 
 cBlockArea::cBlockArea(void) :
-	m_BlockTypes(NULL),
-	m_BlockMetas(NULL),
-	m_BlockLight(NULL),
-	m_BlockSkyLight(NULL)
+	m_BlockTypes(nullptr),
+	m_BlockMetas(nullptr),
+	m_BlockLight(nullptr),
+	m_BlockSkyLight(nullptr)
 {
 }
 
@@ -295,10 +295,10 @@ cBlockArea::~cBlockArea()
 
 void cBlockArea::Clear(void)
 {
-	delete[] m_BlockTypes;    m_BlockTypes    = NULL;
-	delete[] m_BlockMetas;    m_BlockMetas    = NULL;
-	delete[] m_BlockLight;    m_BlockLight    = NULL;
-	delete[] m_BlockSkyLight; m_BlockSkyLight = NULL;
+	delete[] m_BlockTypes;    m_BlockTypes    = nullptr;
+	delete[] m_BlockMetas;    m_BlockMetas    = nullptr;
+	delete[] m_BlockLight;    m_BlockLight    = nullptr;
+	delete[] m_BlockSkyLight; m_BlockSkyLight = nullptr;
 	m_Origin.Set(0, 0, 0);
 	m_Size.Set(0, 0, 0);
 }
@@ -711,7 +711,7 @@ void cBlockArea::Merge(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_R
 	const NIBBLETYPE * SrcMetas = a_Src.GetBlockMetas();
 	NIBBLETYPE * DstMetas = m_BlockMetas;
 	
-	bool IsDummyMetas = ((SrcMetas == NULL) || (DstMetas == NULL));
+	bool IsDummyMetas = ((SrcMetas == nullptr) || (DstMetas == nullptr));
 	
 	if (IsDummyMetas)
 	{
@@ -1013,8 +1013,8 @@ void cBlockArea::RotateCCW(void)
 	}  // for x
 	std::swap(m_BlockTypes, NewTypes);
 	std::swap(m_BlockMetas, NewMetas);
-	delete[] NewTypes;   NewTypes = NULL;
-	delete[] NewMetas;   NewMetas = NULL;
+	delete[] NewTypes;   NewTypes = nullptr;
+	delete[] NewMetas;   NewMetas = nullptr;
 
 	std::swap(m_Size.x, m_Size.z);
 }
@@ -1058,8 +1058,8 @@ void cBlockArea::RotateCW(void)
 	}  // for x
 	std::swap(m_BlockTypes, NewTypes);
 	std::swap(m_BlockMetas, NewMetas);
-	delete[] NewTypes;   NewTypes = NULL;
-	delete[] NewMetas;   NewMetas = NULL;
+	delete[] NewTypes;   NewTypes = nullptr;
+	delete[] NewMetas;   NewMetas = nullptr;
 
 	std::swap(m_Size.x, m_Size.z);
 }
@@ -1206,7 +1206,7 @@ void cBlockArea::RotateCCWNoMeta(void)
 			}  // for z
 		}  // for x
 		std::swap(m_BlockTypes, NewTypes);
-		delete[] NewTypes;   NewTypes = NULL;
+		delete[] NewTypes;   NewTypes = nullptr;
 	}
 	if (HasBlockMetas())
 	{
@@ -1224,7 +1224,7 @@ void cBlockArea::RotateCCWNoMeta(void)
 			}  // for z
 		}  // for x
 		std::swap(m_BlockMetas, NewMetas);
-		delete[] NewMetas;   NewMetas = NULL;
+		delete[] NewMetas;   NewMetas = nullptr;
 	}
 	std::swap(m_Size.x, m_Size.z);
 }
@@ -1251,7 +1251,7 @@ void cBlockArea::RotateCWNoMeta(void)
 			}  // for x
 		}  // for z
 		std::swap(m_BlockTypes, NewTypes);
-		delete[] NewTypes;   NewTypes = NULL;
+		delete[] NewTypes;   NewTypes = nullptr;
 	}
 	if (HasBlockMetas())
 	{
@@ -1269,7 +1269,7 @@ void cBlockArea::RotateCWNoMeta(void)
 			}  // for x
 		}  // for z
 		std::swap(m_BlockMetas, NewMetas);
-		delete[] NewMetas;   NewMetas = NULL;
+		delete[] NewMetas;   NewMetas = nullptr;
 	}
 	std::swap(m_Size.x, m_Size.z);
 }
@@ -1391,7 +1391,7 @@ void cBlockArea::MirrorYZNoMeta(void)
 
 void cBlockArea::SetRelBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType)
 {
-	if (m_BlockTypes == NULL)
+	if (m_BlockTypes == nullptr)
 	{
 		LOGWARNING("cBlockArea: BlockTypes have not been read!");
 		return;
@@ -1468,7 +1468,7 @@ void cBlockArea::SetBlockSkyLight(int a_BlockX, int a_BlockY, int a_BlockZ, NIBB
 
 BLOCKTYPE cBlockArea::GetRelBlockType(int a_RelX, int a_RelY, int a_RelZ) const
 {
-	if (m_BlockTypes == NULL)
+	if (m_BlockTypes == nullptr)
 	{
 		LOGWARNING("cBlockArea: BlockTypes have not been read!");
 		return E_BLOCK_AIR;
@@ -1555,7 +1555,7 @@ void cBlockArea::SetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOC
 void cBlockArea::SetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 {
 	int idx = MakeIndex(a_RelX, a_RelY, a_RelZ);
-	if (m_BlockTypes == NULL)
+	if (m_BlockTypes == nullptr)
 	{
 		LOGWARNING("%s: BlockTypes not available but requested to be written to.", __FUNCTION__);
 	}
@@ -1563,7 +1563,7 @@ void cBlockArea::SetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   B
 	{
 		m_BlockTypes[idx] = a_BlockType;
 	}
-	if (m_BlockMetas == NULL)
+	if (m_BlockMetas == nullptr)
 	{
 		LOGWARNING("%s: BlockMetas not available but requested to be written to.", __FUNCTION__);
 	}
@@ -1589,7 +1589,7 @@ void cBlockArea::GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOC
 void cBlockArea::GetRelBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const
 {
 	int idx = MakeIndex(a_RelX, a_RelY, a_RelZ);
-	if (m_BlockTypes == NULL)
+	if (m_BlockTypes == nullptr)
 	{
 		LOGWARNING("cBlockArea: BlockTypes have not been read!");
 		a_BlockType = E_BLOCK_AIR;
@@ -1599,7 +1599,7 @@ void cBlockArea::GetRelBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTY
 		a_BlockType = m_BlockTypes[idx];
 	}
 	
-	if (m_BlockMetas == NULL)
+	if (m_BlockMetas == nullptr)
 	{
 		LOGWARNING("cBlockArea: BlockMetas have not been read!");
 		a_BlockMeta = 0;
@@ -1617,19 +1617,19 @@ void cBlockArea::GetRelBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTY
 int cBlockArea::GetDataTypes(void) const
 {
 	int res = 0;
-	if (m_BlockTypes != NULL)
+	if (m_BlockTypes != nullptr)
 	{
 		res |= baTypes;
 	}
-	if (m_BlockMetas != NULL)
+	if (m_BlockMetas != nullptr)
 	{
 		res |= baMetas;
 	}
-	if (m_BlockLight != NULL)
+	if (m_BlockLight != nullptr)
 	{
 		res |= baLight;
 	}
-	if (m_BlockSkyLight != NULL)
+	if (m_BlockSkyLight != nullptr)
 	{
 		res |= baSkyLight;
 	}
@@ -1642,12 +1642,12 @@ int cBlockArea::GetDataTypes(void) const
 
 bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 {
-	ASSERT(m_BlockTypes == NULL);  // Has been cleared
+	ASSERT(m_BlockTypes == nullptr);  // Has been cleared
 	
 	if (a_DataTypes & baTypes)
 	{
 		m_BlockTypes = new BLOCKTYPE[a_SizeX * a_SizeY * a_SizeZ];
-		if (m_BlockTypes == NULL)
+		if (m_BlockTypes == nullptr)
 		{
 			return false;
 		}
@@ -1655,36 +1655,36 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 	if (a_DataTypes & baMetas)
 	{
 		m_BlockMetas = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ];
-		if (m_BlockMetas == NULL)
+		if (m_BlockMetas == nullptr)
 		{
 			delete[] m_BlockTypes;
-			m_BlockTypes = NULL;
+			m_BlockTypes = nullptr;
 			return false;
 		}
 	}
 	if (a_DataTypes & baLight)
 	{
 		m_BlockLight = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ];
-		if (m_BlockLight == NULL)
+		if (m_BlockLight == nullptr)
 		{
 			delete[] m_BlockMetas;
-			m_BlockMetas = NULL;
+			m_BlockMetas = nullptr;
 			delete[] m_BlockTypes;
-			m_BlockTypes = NULL;
+			m_BlockTypes = nullptr;
 			return false;
 		}
 	}
 	if (a_DataTypes & baSkyLight)
 	{
 		m_BlockSkyLight = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ];
-		if (m_BlockSkyLight == NULL)
+		if (m_BlockSkyLight == nullptr)
 		{
 			delete[] m_BlockLight;
-			m_BlockLight = NULL;
+			m_BlockLight = nullptr;
 			delete[] m_BlockMetas;
-			m_BlockMetas = NULL;
+			m_BlockMetas = nullptr;
 			delete[] m_BlockTypes;
-			m_BlockTypes = NULL;
+			m_BlockTypes = nullptr;
 			return false;
 		}
 	}
@@ -1714,7 +1714,7 @@ int cBlockArea::MakeIndex(int a_RelX, int a_RelY, int a_RelZ) const
 
 void cBlockArea::SetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array)
 {
-	if (a_Array == NULL)
+	if (a_Array == nullptr)
 	{
 		LOGWARNING("cBlockArea: datatype has not been read!");
 		return;
@@ -1737,7 +1737,7 @@ void cBlockArea::SetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE
 
 NIBBLETYPE cBlockArea::GetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE * a_Array) const
 {
-	if (a_Array == NULL)
+	if (a_Array == nullptr)
 	{
 		LOGWARNING("cBlockArea: datatype has not been read!");
 		return 16;
@@ -1896,7 +1896,7 @@ void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer)
 	}
 	
 	// Copy the blocktypes:
-	if (m_Area.m_BlockTypes != NULL)
+	if (m_Area.m_BlockTypes != nullptr)
 	{
 		for (int y = 0; y < SizeY; y++)
 		{
@@ -1917,7 +1917,7 @@ void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer)
 	}
 
 	// Copy the block metas:
-	if (m_Area.m_BlockMetas != NULL)
+	if (m_Area.m_BlockMetas != nullptr)
 	{
 		for (int y = 0; y < SizeY; y++)
 		{
@@ -1938,7 +1938,7 @@ void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer)
 	}
 
 	// Copy the blocklight:
-	if (m_Area.m_BlockLight != NULL)
+	if (m_Area.m_BlockLight != nullptr)
 	{
 		for (int y = 0; y < SizeY; y++)
 		{
@@ -1959,7 +1959,7 @@ void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer)
 	}
 
 	// Copy the skylight:
-	if (m_Area.m_BlockSkyLight != NULL)
+	if (m_Area.m_BlockSkyLight != nullptr)
 	{
 		for (int y = 0; y < SizeY; y++)
 		{
diff --git a/src/BlockArea.h b/src/BlockArea.h
index 86f7c4f2d..348e960dd 100644
--- a/src/BlockArea.h
+++ b/src/BlockArea.h
@@ -282,10 +282,10 @@ public:
 	/** Returns the datatypes that are stored in the object (bitmask of baXXX values) */
 	int GetDataTypes(void) const;
 	
-	bool HasBlockTypes    (void) const { return (m_BlockTypes    != NULL); }
-	bool HasBlockMetas    (void) const { return (m_BlockMetas    != NULL); }
-	bool HasBlockLights   (void) const { return (m_BlockLight    != NULL); }
-	bool HasBlockSkyLights(void) const { return (m_BlockSkyLight != NULL); }
+	bool HasBlockTypes    (void) const { return (m_BlockTypes    != nullptr); }
+	bool HasBlockMetas    (void) const { return (m_BlockMetas    != nullptr); }
+	bool HasBlockLights   (void) const { return (m_BlockLight    != nullptr); }
+	bool HasBlockSkyLights(void) const { return (m_BlockSkyLight != nullptr); }
 	
 	// tolua_end
 	
diff --git a/src/BlockEntities/BeaconEntity.cpp b/src/BlockEntities/BeaconEntity.cpp
index 02f45a097..85819446c 100644
--- a/src/BlockEntities/BeaconEntity.cpp
+++ b/src/BlockEntities/BeaconEntity.cpp
@@ -97,7 +97,7 @@ bool cBeaconEntity::SetPrimaryEffect(cEntityEffect::eType a_Effect)
 	m_PrimaryEffect = a_Effect;
 
 	// Send window update:
-	if (GetWindow() != NULL)
+	if (GetWindow() != nullptr)
 	{
 		GetWindow()->SetProperty(1, m_PrimaryEffect);
 	}
@@ -119,7 +119,7 @@ bool cBeaconEntity::SetSecondaryEffect(cEntityEffect::eType a_Effect)
 	m_SecondaryEffect = a_Effect;
 
 	// Send window update:
-	if (GetWindow() != NULL)
+	if (GetWindow() != nullptr)
 	{
 		GetWindow()->SetProperty(2, m_SecondaryEffect);
 	}
@@ -184,7 +184,7 @@ void cBeaconEntity::UpdateBeacon(void)
 	if (m_BeaconLevel != OldBeaconLevel)
 	{
 		// Send window update:
-		if (GetWindow() != NULL)
+		if (GetWindow() != nullptr)
 		{
 			GetWindow()->SetProperty(0, m_BeaconLevel);
 		}
@@ -283,13 +283,13 @@ bool cBeaconEntity::Tick(float a_Dt, cChunk & a_Chunk)
 void cBeaconEntity::UsedBy(cPlayer * a_Player)
 {
 	cWindow * Window = GetWindow();
-	if (Window == NULL)
+	if (Window == nullptr)
 	{
 		OpenWindow(new cBeaconWindow(m_PosX, m_PosY, m_PosZ, this));
 		Window = GetWindow();
 	}
 	
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		// if (a_Player->GetWindow() != Window)
 		// -> Because mojang doesn't send a 'close window' packet when you click the cancel button in the beacon inventory ...
diff --git a/src/BlockEntities/BlockEntity.cpp b/src/BlockEntities/BlockEntity.cpp
index 05ad03a3d..3d96e891e 100644
--- a/src/BlockEntities/BlockEntity.cpp
+++ b/src/BlockEntities/BlockEntity.cpp
@@ -48,7 +48,7 @@ cBlockEntity * cBlockEntity::CreateByBlockType(BLOCKTYPE a_BlockType, NIBBLETYPE
 		__FUNCTION__, a_BlockType, ItemTypeToString(a_BlockType).c_str()
 	);
 	ASSERT(!"Requesting creation of an unknown block entity");
-	return NULL;
+	return nullptr;
 }
 
 
diff --git a/src/BlockEntities/BlockEntity.h b/src/BlockEntities/BlockEntity.h
index b04d20340..ffd6ee856 100644
--- a/src/BlockEntities/BlockEntity.h
+++ b/src/BlockEntities/BlockEntity.h
@@ -70,8 +70,8 @@ public:
 	
 	/// Creates a new block entity for the specified block type
 	/// If a_World is valid, then the entity is created bound to that world
-	/// Returns NULL for unknown block types
-	static cBlockEntity * CreateByBlockType(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World = NULL);
+	/// Returns nullptr for unknown block types
+	static cBlockEntity * CreateByBlockType(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World = nullptr);
 	
 	static const char * GetClassStatic(void)  // Needed for ManualBindings's ForEach templates
 	{
diff --git a/src/BlockEntities/BlockEntityWithItems.h b/src/BlockEntities/BlockEntityWithItems.h
index cb7bc2fb4..8c7d4749b 100644
--- a/src/BlockEntities/BlockEntityWithItems.h
+++ b/src/BlockEntities/BlockEntityWithItems.h
@@ -47,7 +47,7 @@ public:
 	virtual void Destroy(void) override
 	{
 		// Drop the contents as pickups:
-		ASSERT(m_World != NULL);
+		ASSERT(m_World != nullptr);
 		cItems Pickups;
 		m_Contents.CopyToItems(Pickups);
 		m_Contents.Clear();
@@ -78,9 +78,9 @@ protected:
 	{
 		UNUSED(a_SlotNum);
 		ASSERT(a_Grid == &m_Contents);
-		if (m_World != NULL)
+		if (m_World != nullptr)
 		{
-			if (GetWindow() != NULL)
+			if (GetWindow() != nullptr)
 			{
 				GetWindow()->BroadcastWholeWindow();
 			}
diff --git a/src/BlockEntities/ChestEntity.cpp b/src/BlockEntities/ChestEntity.cpp
index 19d88b646..0cd9c66e0 100644
--- a/src/BlockEntities/ChestEntity.cpp
+++ b/src/BlockEntities/ChestEntity.cpp
@@ -23,7 +23,7 @@ cChestEntity::cChestEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_
 cChestEntity::~cChestEntity()
 {
 	cWindow * Window = GetWindow();
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		Window->OwnerDestroyed();
 	}
@@ -49,14 +49,14 @@ void cChestEntity::UsedBy(cPlayer * a_Player)
 {
 	// If the window is not created, open it anew:
 	cWindow * Window = GetWindow();
-	if (Window == NULL)
+	if (Window == nullptr)
 	{
 		OpenNewWindow();
 		Window = GetWindow();
 	}
 	
 	// Open the window for the player:
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		if (a_Player->GetWindow() != Window)
 		{
diff --git a/src/BlockEntities/CommandBlockEntity.cpp b/src/BlockEntities/CommandBlockEntity.cpp
index 1a5a3f01e..b7f938ffd 100644
--- a/src/BlockEntities/CommandBlockEntity.cpp
+++ b/src/BlockEntities/CommandBlockEntity.cpp
@@ -154,7 +154,7 @@ void cCommandBlockEntity::SendTo(cClientHandle & a_Client)
 
 void cCommandBlockEntity::Execute()
 {
-	ASSERT(m_World != NULL);  // Execute should not be called before the command block is attached to a world
+	ASSERT(m_World != nullptr);  // Execute should not be called before the command block is attached to a world
 	
 	if (!m_World->AreCommandBlocksEnabled())
 	{
diff --git a/src/BlockEntities/DispenserEntity.cpp b/src/BlockEntities/DispenserEntity.cpp
index aea854dc2..82c234a14 100644
--- a/src/BlockEntities/DispenserEntity.cpp
+++ b/src/BlockEntities/DispenserEntity.cpp
@@ -28,7 +28,7 @@ void cDispenserEntity::DropSpenseFromSlot(cChunk & a_Chunk, int a_SlotNum)
 	NIBBLETYPE Meta = a_Chunk.GetMeta(m_RelX, m_PosY, m_RelZ);
 	AddDropSpenserDir(DispX, DispY, DispZ, Meta);
 	cChunk * DispChunk = a_Chunk.GetRelNeighborChunkAdjustCoords(DispX, DispZ);
-	if (DispChunk == NULL)
+	if (DispChunk == nullptr)
 	{
 		// Would dispense into / interact with a non-loaded chunk, ignore the tick
 		return;
@@ -190,7 +190,7 @@ void cDispenserEntity::DropSpenseFromSlot(cChunk & a_Chunk, int a_SlotNum)
 
 void cDispenserEntity::SpawnProjectileFromDispenser(int a_BlockX, int a_BlockY, int a_BlockZ, cProjectileEntity::eKind a_Kind, const Vector3d & a_ShootVector)
 {
-	m_World->CreateProjectile((double)a_BlockX + 0.5, (double)a_BlockY + 0.5, (double)a_BlockZ + 0.5, a_Kind, NULL, NULL, &a_ShootVector);
+	m_World->CreateProjectile((double)a_BlockX + 0.5, (double)a_BlockY + 0.5, (double)a_BlockZ + 0.5, a_Kind, nullptr, nullptr, &a_ShootVector);
 }
 
 
diff --git a/src/BlockEntities/DropSpenserEntity.cpp b/src/BlockEntities/DropSpenserEntity.cpp
index dac951b27..3f98836e7 100644
--- a/src/BlockEntities/DropSpenserEntity.cpp
+++ b/src/BlockEntities/DropSpenserEntity.cpp
@@ -28,7 +28,7 @@ cDropSpenserEntity::~cDropSpenserEntity()
 {
 	// Tell window its owner is destroyed
 	cWindow * Window = GetWindow();
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		Window->OwnerDestroyed();
 	}
@@ -155,13 +155,13 @@ void cDropSpenserEntity::SendTo(cClientHandle & a_Client)
 void cDropSpenserEntity::UsedBy(cPlayer * a_Player)
 {
 	cWindow * Window = GetWindow();
-	if (Window == NULL)
+	if (Window == nullptr)
 	{
 		OpenWindow(new cDropSpenserWindow(m_PosX, m_PosY, m_PosZ, this));
 		Window = GetWindow();
 	}
 	
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		if (a_Player->GetWindow() != Window)
 		{
diff --git a/src/BlockEntities/EnderChestEntity.cpp b/src/BlockEntities/EnderChestEntity.cpp
index 0654d97dd..e18490a1e 100644
--- a/src/BlockEntities/EnderChestEntity.cpp
+++ b/src/BlockEntities/EnderChestEntity.cpp
@@ -23,7 +23,7 @@ cEnderChestEntity::cEnderChestEntity(int a_BlockX, int a_BlockY, int a_BlockZ, c
 cEnderChestEntity::~cEnderChestEntity()
 {
 	cWindow * Window = GetWindow();
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		Window->OwnerDestroyed();
 	}
@@ -37,14 +37,14 @@ void cEnderChestEntity::UsedBy(cPlayer * a_Player)
 {
 	// If the window is not created, open it anew:
 	cWindow * Window = GetWindow();
-	if (Window == NULL)
+	if (Window == nullptr)
 	{
 		OpenNewWindow();
 		Window = GetWindow();
 	}
 	
 	// Open the window for the player:
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		if (a_Player->GetWindow() != Window)
 		{
diff --git a/src/BlockEntities/FlowerPotEntity.cpp b/src/BlockEntities/FlowerPotEntity.cpp
index 01560f814..9db3b268b 100644
--- a/src/BlockEntities/FlowerPotEntity.cpp
+++ b/src/BlockEntities/FlowerPotEntity.cpp
@@ -59,7 +59,7 @@ void cFlowerPotEntity::Destroy(void)
 	// Drop the contents as pickups:
 	if (!m_Item.IsEmpty())
 	{
-		ASSERT(m_World != NULL);
+		ASSERT(m_World != nullptr);
 		cItems Pickups;
 		Pickups.Add(m_Item);
 		m_World->SpawnItemPickups(Pickups, m_PosX + 0.5, m_PosY + 0.5, m_PosZ + 0.5);
diff --git a/src/BlockEntities/FlowerPotEntity.h b/src/BlockEntities/FlowerPotEntity.h
index 5b86621f5..fc886c51f 100644
--- a/src/BlockEntities/FlowerPotEntity.h
+++ b/src/BlockEntities/FlowerPotEntity.h
@@ -38,7 +38,7 @@ public:
 	
 	BLOCKENTITY_PROTODEF(cFlowerPotEntity);
 	
-	/** Creates a new flowerpot entity at the specified block coords. a_World may be NULL */
+	/** Creates a new flowerpot entity at the specified block coords. a_World may be nullptr */
 	cFlowerPotEntity(int a_BlocX, int a_BlockY, int a_BlockZ, cWorld * a_World);
 	
 	virtual void Destroy(void) override;
diff --git a/src/BlockEntities/FurnaceEntity.cpp b/src/BlockEntities/FurnaceEntity.cpp
index 284ac7de9..85f68b00b 100644
--- a/src/BlockEntities/FurnaceEntity.cpp
+++ b/src/BlockEntities/FurnaceEntity.cpp
@@ -26,7 +26,7 @@ enum
 cFurnaceEntity::cFurnaceEntity(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cWorld * a_World) :
 	super(a_BlockType, a_BlockX, a_BlockY, a_BlockZ, ContentsWidth, ContentsHeight, a_World),
 	m_BlockMeta(a_BlockMeta),
-	m_CurrentRecipe(NULL),
+	m_CurrentRecipe(nullptr),
 	m_IsDestroyed(false),
 	m_IsCooking(a_BlockType == E_BLOCK_LIT_FURNACE),
 	m_NeedCookTime(0),
@@ -45,7 +45,7 @@ cFurnaceEntity::~cFurnaceEntity()
 {
 	// Tell window its owner is destroyed
 	cWindow * Window = GetWindow();
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		Window->OwnerDestroyed();
 	}
@@ -145,7 +145,7 @@ void cFurnaceEntity::SendTo(cClientHandle & a_Client)
 void cFurnaceEntity::BroadcastProgress(short a_ProgressbarID, short a_Value)
 {
 	cWindow * Window = GetWindow();
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		Window->SetProperty(a_ProgressbarID, a_Value);
 	}
@@ -306,7 +306,7 @@ void cFurnaceEntity::UpdateOutput(void)
 
 bool cFurnaceEntity::CanCookInputToOutput(void) const
 {
-	if (m_CurrentRecipe == NULL)
+	if (m_CurrentRecipe == nullptr)
 	{
 		// This input cannot be cooked
 		return false;
diff --git a/src/BlockEntities/HopperEntity.cpp b/src/BlockEntities/HopperEntity.cpp
index 103f516fc..5ed25ce99 100644
--- a/src/BlockEntities/HopperEntity.cpp
+++ b/src/BlockEntities/HopperEntity.cpp
@@ -86,14 +86,14 @@ void cHopperEntity::UsedBy(cPlayer * a_Player)
 {
 	// If the window is not created, open it anew:
 	cWindow * Window = GetWindow();
-	if (Window == NULL)
+	if (Window == nullptr)
 	{
 		OpenNewWindow();
 		Window = GetWindow();
 	}
 	
 	// Open the window for the player:
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		if (a_Player->GetWindow() != Window)
 		{
@@ -197,7 +197,7 @@ bool cHopperEntity::MovePickupsIn(cChunk & a_Chunk, Int64 a_CurrentTick)
 
 		virtual bool Item(cEntity * a_Entity) override
 		{
-			ASSERT(a_Entity != NULL);
+			ASSERT(a_Entity != nullptr);
 
 			if (!a_Entity->IsPickup() || a_Entity->IsDestroyed())
 			{
@@ -299,7 +299,7 @@ bool cHopperEntity::MoveItemsOut(cChunk & a_Chunk, Int64 a_CurrentTick)
 	int OutRelX = OutX - a_Chunk.GetPosX() * cChunkDef::Width;
 	int OutRelZ = OutZ - a_Chunk.GetPosZ() * cChunkDef::Width;
 	cChunk * DestChunk = a_Chunk.GetRelNeighborChunkAdjustCoords(OutRelX, OutRelZ);
-	if (DestChunk == NULL)
+	if (DestChunk == nullptr)
 	{
 		// The destination chunk has been unloaded, don't tick
 		return false;
@@ -328,7 +328,7 @@ bool cHopperEntity::MoveItemsOut(cChunk & a_Chunk, Int64 a_CurrentTick)
 		case E_BLOCK_HOPPER:
 		{
 			cBlockEntityWithItems * BlockEntity = (cBlockEntityWithItems *)DestChunk->GetBlockEntity(OutX, OutY, OutZ);
-			if (BlockEntity == NULL)
+			if (BlockEntity == nullptr)
 			{
 				LOGWARNING("%s: A block entity was not found where expected at {%d, %d, %d}", __FUNCTION__, OutX, OutY, OutZ);
 				return false;
@@ -355,7 +355,7 @@ bool cHopperEntity::MoveItemsOut(cChunk & a_Chunk, Int64 a_CurrentTick)
 bool cHopperEntity::MoveItemsFromChest(cChunk & a_Chunk)
 {
 	cChestEntity * MainChest = (cChestEntity *)a_Chunk.GetBlockEntity(m_PosX, m_PosY + 1, m_PosZ);
-	if (MainChest == NULL)
+	if (MainChest == nullptr)
 	{
 		LOGWARNING("%s: A chest entity was not found where expected, at {%d, %d, %d}", __FUNCTION__, m_PosX, m_PosY + 1, m_PosZ);
 		return false;
@@ -383,7 +383,7 @@ bool cHopperEntity::MoveItemsFromChest(cChunk & a_Chunk)
 		int x = m_RelX + Coords[i].x;
 		int z = m_RelZ + Coords[i].z;
 		cChunk * Neighbor = a_Chunk.GetRelNeighborChunkAdjustCoords(x, z);
-		if (Neighbor == NULL)
+		if (Neighbor == nullptr)
 		{
 			continue;
 		}
@@ -396,7 +396,7 @@ bool cHopperEntity::MoveItemsFromChest(cChunk & a_Chunk)
 		}
 
 		cChestEntity * SideChest = (cChestEntity *)Neighbor->GetBlockEntity(m_PosX + Coords[i].x, m_PosY + 1, m_PosZ + Coords[i].z);
-		if (SideChest == NULL)
+		if (SideChest == nullptr)
 		{
 			LOGWARNING("%s: A chest entity was not found where expected, at {%d, %d, %d}", __FUNCTION__, m_PosX + Coords[i].x, m_PosY + 1, m_PosZ + Coords[i].z);
 		}
@@ -422,7 +422,7 @@ bool cHopperEntity::MoveItemsFromChest(cChunk & a_Chunk)
 bool cHopperEntity::MoveItemsFromFurnace(cChunk & a_Chunk)
 {
 	cFurnaceEntity * Furnace = (cFurnaceEntity *)a_Chunk.GetBlockEntity(m_PosX, m_PosY + 1, m_PosZ);
-	if (Furnace == NULL)
+	if (Furnace == nullptr)
 	{
 		LOGWARNING("%s: A furnace entity was not found where expected, at {%d, %d, %d}", __FUNCTION__, m_PosX, m_PosY + 1, m_PosZ);
 		return false;
@@ -536,7 +536,7 @@ bool cHopperEntity::MoveItemsToChest(cChunk & a_Chunk, int a_BlockX, int a_Block
 {
 	// Try the chest directly connected to the hopper:
 	cChestEntity * ConnectedChest = (cChestEntity *)a_Chunk.GetBlockEntity(a_BlockX, a_BlockY, a_BlockZ);
-	if (ConnectedChest == NULL)
+	if (ConnectedChest == nullptr)
 	{
 		LOGWARNING("%s: A chest entity was not found where expected, at {%d, %d, %d}", __FUNCTION__, a_BlockX, a_BlockY, a_BlockZ);
 		return false;
@@ -566,7 +566,7 @@ bool cHopperEntity::MoveItemsToChest(cChunk & a_Chunk, int a_BlockX, int a_Block
 		int x = RelX + Coords[i].x;
 		int z = RelZ + Coords[i].z;
 		cChunk * Neighbor = a_Chunk.GetRelNeighborChunkAdjustCoords(x, z);
-		if (Neighbor == NULL)
+		if (Neighbor == nullptr)
 		{
 			continue;
 		}
@@ -579,7 +579,7 @@ bool cHopperEntity::MoveItemsToChest(cChunk & a_Chunk, int a_BlockX, int a_Block
 		}
 
 		cChestEntity * Chest = (cChestEntity *)Neighbor->GetBlockEntity(a_BlockX + Coords[i].x, a_BlockY, a_BlockZ + Coords[i].z);
-		if (Chest == NULL)
+		if (Chest == nullptr)
 		{
 			LOGWARNING("%s: A chest entity was not found where expected, at {%d, %d, %d} (%d, %d)", __FUNCTION__, a_BlockX + Coords[i].x, a_BlockY, a_BlockZ + Coords[i].z, x, z);
 			continue;
diff --git a/src/BlockEntities/MobHeadEntity.h b/src/BlockEntities/MobHeadEntity.h
index 7f69bc5ad..7132ef558 100644
--- a/src/BlockEntities/MobHeadEntity.h
+++ b/src/BlockEntities/MobHeadEntity.h
@@ -36,7 +36,7 @@ public:
 	
 	BLOCKENTITY_PROTODEF(cMobHeadEntity);
 	
-	/** Creates a new mob head entity at the specified block coords. a_World may be NULL */
+	/** Creates a new mob head entity at the specified block coords. a_World may be nullptr */
 	cMobHeadEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World);
 
 	// tolua_begin
diff --git a/src/BlockEntities/NoteEntity.h b/src/BlockEntities/NoteEntity.h
index 74dbde046..fc5f27d07 100644
--- a/src/BlockEntities/NoteEntity.h
+++ b/src/BlockEntities/NoteEntity.h
@@ -42,7 +42,7 @@ public:
 
 	BLOCKENTITY_PROTODEF(cNoteEntity);
 	
-	/// Creates a new note entity. a_World may be NULL
+	/// Creates a new note entity. a_World may be nullptr
 	cNoteEntity(int a_X, int a_Y, int a_Z, cWorld * a_World);
 	virtual ~cNoteEntity() {}
 
diff --git a/src/BlockEntities/SignEntity.h b/src/BlockEntities/SignEntity.h
index be13c7a32..52baa486d 100644
--- a/src/BlockEntities/SignEntity.h
+++ b/src/BlockEntities/SignEntity.h
@@ -36,7 +36,7 @@ public:
 	
 	BLOCKENTITY_PROTODEF(cSignEntity);
 	
-	/// Creates a new empty sign entity at the specified block coords and block type (wall or standing). a_World may be NULL
+	/// Creates a new empty sign entity at the specified block coords and block type (wall or standing). a_World may be nullptr
 	cSignEntity(BLOCKTYPE a_BlockType, int a_X, int a_Y, int a_Z, cWorld * a_World);
 
 	// tolua_begin
diff --git a/src/BlockInfo.cpp b/src/BlockInfo.cpp
index bdd3a9c26..bcab21e77 100644
--- a/src/BlockInfo.cpp
+++ b/src/BlockInfo.cpp
@@ -9,7 +9,7 @@
 cBlockInfo::~cBlockInfo()
 {
 	delete m_Handler;
-	m_Handler = NULL;
+	m_Handler = nullptr;
 }
 
 
@@ -17,7 +17,7 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 {
 	for (unsigned int i = 0; i < 256; ++i)
 	{
-		if (a_Info[i].m_Handler == NULL)
+		if (a_Info[i].m_Handler == nullptr)
 		{
 			a_Info[i].m_Handler = cBlockHandler::CreateBlockHandler((BLOCKTYPE) i);
 		}
diff --git a/src/BlockInfo.h b/src/BlockInfo.h
index 1e4cf2ca0..4709f2357 100644
--- a/src/BlockInfo.h
+++ b/src/BlockInfo.h
@@ -102,7 +102,7 @@ protected:
 		, m_FullyOccupiesVoxel(false)
 		, m_CanBeTerraformed(false)
 		, m_PlaceSound("")
-		, m_Handler(NULL)
+		, m_Handler(nullptr)
 	{}
 
 	/** Cleans up the stored values */
diff --git a/src/Blocks/BlockDirt.h b/src/Blocks/BlockDirt.h
index 89dfc963d..aae6719e2 100644
--- a/src/Blocks/BlockDirt.h
+++ b/src/Blocks/BlockDirt.h
@@ -72,7 +72,7 @@ public:
 			int BlockY = a_RelY + OfsY;
 			int BlockZ = a_RelZ + OfsZ;
 			cChunk * Chunk = a_Chunk.GetRelNeighborChunkAdjustCoords(BlockX, BlockZ);
-			if (Chunk == NULL)
+			if (Chunk == nullptr)
 			{
 				// Unloaded chunk
 				continue;
diff --git a/src/Blocks/BlockHandler.cpp b/src/Blocks/BlockHandler.cpp
index b6ef5dd6f..60f13a747 100644
--- a/src/Blocks/BlockHandler.cpp
+++ b/src/Blocks/BlockHandler.cpp
@@ -99,9 +99,9 @@ public:
 		for (BLOCKTYPE Type = 0; Type < E_BLOCK_MAX_TYPE_ID; Type++)
 		{
 			cBlockHandler * Handler = cBlockInfo::GetHandler(Type);
-			if (Handler == NULL)
+			if (Handler == nullptr)
 			{
-				printf("NULL handler for block type %d!\n", Type);
+				printf("nullptr handler for block type %d!\n", Type);
 				continue;
 			}
 			AString BlockName = ItemTypeToString(Type);
@@ -441,7 +441,7 @@ void cBlockHandler::DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterfac
 
 	if (a_CanDrop)
 	{
-		if ((a_Digger != NULL) && (a_Digger->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchSilkTouch) > 0))
+		if ((a_Digger != nullptr) && (a_Digger->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchSilkTouch) > 0))
 		{
 			switch (m_BlockType)
 			{
@@ -562,7 +562,7 @@ void cBlockHandler::Check(cChunkInterface & a_ChunkInterface, cBlockPluginInterf
 		{
 			int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
 			int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
-			DropBlock(a_ChunkInterface, *a_Chunk.GetWorld(), a_PluginInterface, NULL, BlockX, a_RelY, BlockZ);
+			DropBlock(a_ChunkInterface, *a_Chunk.GetWorld(), a_PluginInterface, nullptr, BlockX, a_RelY, BlockZ);
 		}
 		
 		a_Chunk.SetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_AIR, 0);
diff --git a/src/Blocks/BlockHandler.h b/src/Blocks/BlockHandler.h
index 83de836cb..f2298afb5 100644
--- a/src/Blocks/BlockHandler.h
+++ b/src/Blocks/BlockHandler.h
@@ -78,7 +78,7 @@ public:
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta);
 	
 	/** Handles the dropping, but not destruction, of a block based on what ConvertTo(Verbatim)Pickups() returns, including the spawning of pickups and alertion of plugins
-	@param a_Digger The entity causing the drop; it may be NULL
+	@param a_Digger The entity causing the drop; it may be nullptr
 	@param a_CanDrop Informs the handler whether the block should be dropped at all. One example when this is false is when stone is destroyed by hand
 	@param a_DropVerbatim Calls ConvertToVerbatimPickups() instead of its counterpart, meaning the block itself is dropped by default (due to a speical tool or enchantment)
 	*/
diff --git a/src/Blocks/BlockLeaves.h b/src/Blocks/BlockLeaves.h
index add571675..bd9a7414e 100644
--- a/src/Blocks/BlockLeaves.h
+++ b/src/Blocks/BlockLeaves.h
@@ -109,7 +109,7 @@ public:
 		}
 
 		// Decay the leaves:
-		DropBlock(a_ChunkInterface, a_WorldInterface, a_PluginInterface, NULL, BlockX, a_RelY, BlockZ);
+		DropBlock(a_ChunkInterface, a_WorldInterface, a_PluginInterface, nullptr, BlockX, a_RelY, BlockZ);
 		a_ChunkInterface.DigBlock(a_WorldInterface, BlockX, a_RelY, BlockZ);
 	}
 } ;
diff --git a/src/Blocks/BlockPiston.cpp b/src/Blocks/BlockPiston.cpp
index 34d11f675..8d245cabe 100644
--- a/src/Blocks/BlockPiston.cpp
+++ b/src/Blocks/BlockPiston.cpp
@@ -139,7 +139,7 @@ void cBlockPistonHandler::ExtendPiston(int a_BlockX, int a_BlockY, int a_BlockZ,
 		{
 			cChunkInterface ChunkInterface(a_World->GetChunkMap());
 			cBlockInServerPluginInterface PluginInterface(*a_World);
-			Handler->DropBlock(ChunkInterface, *a_World, PluginInterface, NULL, a_BlockX, a_BlockY, a_BlockZ);
+			Handler->DropBlock(ChunkInterface, *a_World, PluginInterface, nullptr, a_BlockX, a_BlockY, a_BlockZ);
 		}
 	}
 
diff --git a/src/Blocks/BlockVine.h b/src/Blocks/BlockVine.h
index 213324cc1..04021bc47 100644
--- a/src/Blocks/BlockVine.h
+++ b/src/Blocks/BlockVine.h
@@ -138,7 +138,7 @@ public:
 				{
 					int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
 					int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
-					DropBlock(a_ChunkInterface, *a_Chunk.GetWorld(), a_PluginInterface, NULL, BlockX, a_RelY, BlockZ);
+					DropBlock(a_ChunkInterface, *a_Chunk.GetWorld(), a_PluginInterface, nullptr, BlockX, a_RelY, BlockZ);
 				}
 				a_Chunk.SetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_AIR, 0);
 				return;
diff --git a/src/Blocks/BroadcastInterface.h b/src/Blocks/BroadcastInterface.h
index cf332b153..bf464627d 100644
--- a/src/Blocks/BroadcastInterface.h
+++ b/src/Blocks/BroadcastInterface.h
@@ -7,6 +7,6 @@ public:
 	virtual ~cBroadcastInterface() {}
 	
 	virtual void BroadcastUseBed     (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) = 0;
-	virtual void BroadcastSoundEffect(const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL) = 0;
-	virtual void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL) = 0;
+	virtual void BroadcastSoundEffect(const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = nullptr) = 0;
+	virtual void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = nullptr) = 0;
 };
diff --git a/src/ByteBuffer.cpp b/src/ByteBuffer.cpp
index d03b6bbe4..6406a2625 100644
--- a/src/ByteBuffer.cpp
+++ b/src/ByteBuffer.cpp
@@ -131,7 +131,7 @@ cByteBuffer::~cByteBuffer()
 {
 	CheckValid();
 	delete[] m_Buffer;
-	m_Buffer = NULL;
+	m_Buffer = nullptr;
 }
 
 
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index 2a835a43d..f70393bb8 100644
--- a/src/Chunk.cpp
+++ b/src/Chunk.cpp
@@ -94,19 +94,19 @@ cChunk::cChunk(
 	m_RedstoneSimulatorData(a_World->GetRedstoneSimulator()->CreateChunkData()),
 	m_AlwaysTicked(0)
 {
-	if (a_NeighborXM != NULL)
+	if (a_NeighborXM != nullptr)
 	{
 		a_NeighborXM->m_NeighborXP = this;
 	}
-	if (a_NeighborXP != NULL)
+	if (a_NeighborXP != nullptr)
 	{
 		a_NeighborXP->m_NeighborXM = this;
 	}
-	if (a_NeighborZM != NULL)
+	if (a_NeighborZM != nullptr)
 	{
 		a_NeighborZM->m_NeighborZP = this;
 	}
-	if (a_NeighborZP != NULL)
+	if (a_NeighborZP != nullptr)
 	{
 		a_NeighborZP->m_NeighborZM = this;
 	}
@@ -140,28 +140,28 @@ cChunk::~cChunk()
 		}
 	}
 	
-	if (m_NeighborXM != NULL)
+	if (m_NeighborXM != nullptr)
 	{
-		m_NeighborXM->m_NeighborXP = NULL;
+		m_NeighborXM->m_NeighborXP = nullptr;
 	}
-	if (m_NeighborXP != NULL)
+	if (m_NeighborXP != nullptr)
 	{
-		m_NeighborXP->m_NeighborXM = NULL;
+		m_NeighborXP->m_NeighborXM = nullptr;
 	}
-	if (m_NeighborZM != NULL)
+	if (m_NeighborZM != nullptr)
 	{
-		m_NeighborZM->m_NeighborZP = NULL;
+		m_NeighborZM->m_NeighborZP = nullptr;
 	}
-	if (m_NeighborZP != NULL)
+	if (m_NeighborZP != nullptr)
 	{
-		m_NeighborZP->m_NeighborZM = NULL;
+		m_NeighborZP->m_NeighborZM = nullptr;
 	}
 	delete m_WaterSimulatorData;
-	m_WaterSimulatorData = NULL;
+	m_WaterSimulatorData = nullptr;
 	delete m_LavaSimulatorData;
-	m_LavaSimulatorData = NULL;
+	m_LavaSimulatorData = nullptr;
 	delete m_RedstoneSimulatorData;
-	m_RedstoneSimulatorData = NULL;
+	m_RedstoneSimulatorData = nullptr;
 }
 
 
@@ -580,7 +580,7 @@ void cChunk::SpawnMobs(cMobSpawner& a_MobSpawner)
 		}
 		
 		cEntity * newMob = a_MobSpawner.TryToSpawnHere(this, TryX, TryY, TryZ, Biome, MaxNbOfSuccess);
-		if (newMob == NULL)
+		if (newMob == nullptr)
 		{
 			continue;
 		}
@@ -638,7 +638,7 @@ void cChunk::Tick(float a_Dt)
 		{
 			// Remove all entities that are travelling to another world
 			MarkDirty();
-			(*itr)->SetWorldTravellingFrom(NULL);
+			(*itr)->SetWorldTravellingFrom(nullptr);
 			itr = m_Entities.erase(itr);
 		}
 		else if (
@@ -667,7 +667,7 @@ void cChunk::Tick(float a_Dt)
 void cChunk::TickBlock(int a_RelX, int a_RelY, int a_RelZ)
 {
 	cBlockHandler * Handler = BlockHandler(GetBlock(a_RelX, a_RelY, a_RelZ));
-	ASSERT(Handler != NULL);  // Happenned on server restart, FS #243
+	ASSERT(Handler != nullptr);  // Happenned on server restart, FS #243
 	cChunkInterface ChunkInterface(this->GetWorld()->GetChunkMap());
 	cBlockInServerPluginInterface PluginInterface(*this->GetWorld());
 	Handler->OnUpdate(ChunkInterface, *this->GetWorld(), PluginInterface, *this, a_RelX, a_RelY, a_RelZ);
@@ -680,10 +680,10 @@ void cChunk::TickBlock(int a_RelX, int a_RelY, int a_RelZ)
 void cChunk::MoveEntityToNewChunk(cEntity * a_Entity)
 {
 	cChunk * Neighbor = GetNeighborChunk(a_Entity->GetChunkX() * cChunkDef::Width, a_Entity->GetChunkZ() * cChunkDef::Width);
-	if (Neighbor == NULL)
+	if (Neighbor == nullptr)
 	{
 		Neighbor = m_ChunkMap->GetChunkNoLoad(a_Entity->GetChunkX(), a_Entity->GetChunkZ());
-		if (Neighbor == NULL)
+		if (Neighbor == nullptr)
 		{
 			// TODO: What to do with this?
 			LOGWARNING("%s: Failed to move entity, destination chunk unreachable. Entity lost", __FUNCTION__);
@@ -846,7 +846,7 @@ void cChunk::TickBlocks(void)
 		}
 
 		cBlockHandler * Handler = BlockHandler(GetBlock(m_BlockTickX, m_BlockTickY, m_BlockTickZ));
-		ASSERT(Handler != NULL);  // Happenned on server restart, FS #243
+		ASSERT(Handler != nullptr);  // Happenned on server restart, FS #243
 		Handler->OnUpdate(ChunkInterface, *this->GetWorld(), PluginInterface, *this, m_BlockTickX, m_BlockTickY, m_BlockTickZ);
 	}  // for i - tickblocks
 }
@@ -1126,7 +1126,7 @@ bool cChunk::UnboundedRelGetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE
 		return false;
 	}
 	cChunk * Chunk = GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		// The chunk is not available, bail out
 		return false;
@@ -1147,7 +1147,7 @@ bool cChunk::UnboundedRelGetBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKT
 		return false;
 	}
 	cChunk * Chunk = GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		// The chunk is not available, bail out
 		return false;
@@ -1168,7 +1168,7 @@ bool cChunk::UnboundedRelGetBlockMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLE
 		return false;
 	}
 	cChunk * Chunk = GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		// The chunk is not available, bail out
 		return false;
@@ -1189,7 +1189,7 @@ bool cChunk::UnboundedRelGetBlockBlockLight(int a_RelX, int a_RelY, int a_RelZ,
 		return false;
 	}
 	cChunk * Chunk = GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		// The chunk is not available, bail out
 		return false;
@@ -1210,7 +1210,7 @@ bool cChunk::UnboundedRelGetBlockSkyLight(int a_RelX, int a_RelY, int a_RelZ, NI
 		return false;
 	}
 	cChunk * Chunk = GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		// The chunk is not available, bail out
 		return false;
@@ -1231,7 +1231,7 @@ bool cChunk::UnboundedRelGetBlockLights(int a_RelX, int a_RelY, int a_RelZ, NIBB
 		return false;
 	}
 	cChunk * Chunk = GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		// The chunk is not available, bail out
 		return false;
@@ -1253,7 +1253,7 @@ bool cChunk::UnboundedRelSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE
 		return false;
 	}
 	cChunk * Chunk = GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		// The chunk is not available, bail out
 		return false;
@@ -1274,7 +1274,7 @@ bool cChunk::UnboundedRelFastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKT
 		return false;
 	}
 	cChunk * Chunk = GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		// The chunk is not available, bail out
 		return false;
@@ -1295,7 +1295,7 @@ void cChunk::UnboundedQueueTickBlock(int a_RelX, int a_RelY, int a_RelZ)
 		return;
 	}
 	cChunk * Chunk = GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		Chunk->QueueTickBlock(a_RelX, a_RelY, a_RelZ);
 	}
@@ -1451,12 +1451,12 @@ void cChunk::SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType,
 	// If there was a block entity, remove it:
 	Vector3i WorldPos = PositionToWorldPosition(a_RelX, a_RelY, a_RelZ);
 	cBlockEntity * BlockEntity = GetBlockEntity(WorldPos);
-	if (BlockEntity != NULL)
+	if (BlockEntity != nullptr)
 	{
 		BlockEntity->Destroy();
 		RemoveBlockEntity(BlockEntity);
 		delete BlockEntity;
-		BlockEntity = NULL;
+		BlockEntity = nullptr;
 	}
 	
 	// If the new block is a block entity, create the entity object:
@@ -1618,7 +1618,7 @@ void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockT
 void cChunk::SendBlockTo(int a_RelX, int a_RelY, int a_RelZ, cClientHandle * a_Client)
 {
 
-	if (a_Client == NULL)
+	if (a_Client == nullptr)
 	{
 		// Queue the block for all clients in the chunk (will be sent in Tick())
 		m_PendingSendBlocks.push_back(sSetBlock(m_PosX, m_PosZ, a_RelX, a_RelY, a_RelZ, GetBlock(a_RelX, a_RelY, a_RelZ), GetMeta(a_RelX, a_RelY, a_RelZ)));
@@ -1672,7 +1672,7 @@ cBlockEntity * cChunk::GetBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ)
 		}
 	}  // for itr - m_BlockEntities[]
 	
-	return NULL;
+	return nullptr;
 }
 
 
@@ -1707,7 +1707,7 @@ void cChunk::SetAlwaysTicked(bool a_AlwaysTicked)
 void cChunk::UseBlockEntity(cPlayer * a_Player, int a_X, int a_Y, int a_Z)
 {
 	cBlockEntity * be = GetBlockEntity(a_X, a_Y, a_Z);
-	if (be != NULL)
+	if (be != nullptr)
 	{
 		be->UsedBy(a_Player);
 	}
@@ -2663,10 +2663,10 @@ cChunk * cChunk::GetRelNeighborChunk(int a_RelX, int a_RelZ)
 	bool ReturnThis = true;
 	if (a_RelX < 0)
 	{
-		if (m_NeighborXM != NULL)
+		if (m_NeighborXM != nullptr)
 		{
 			cChunk * Candidate = m_NeighborXM->GetRelNeighborChunk(a_RelX + cChunkDef::Width, a_RelZ);
-			if (Candidate != NULL)
+			if (Candidate != nullptr)
 			{
 				return Candidate;
 			}
@@ -2676,10 +2676,10 @@ cChunk * cChunk::GetRelNeighborChunk(int a_RelX, int a_RelZ)
 	}
 	else if (a_RelX >= cChunkDef::Width)
 	{
-		if (m_NeighborXP != NULL)
+		if (m_NeighborXP != nullptr)
 		{
 			cChunk * Candidate = m_NeighborXP->GetRelNeighborChunk(a_RelX - cChunkDef::Width, a_RelZ);
-			if (Candidate != NULL)
+			if (Candidate != nullptr)
 			{
 				return Candidate;
 			}
@@ -2690,24 +2690,24 @@ cChunk * cChunk::GetRelNeighborChunk(int a_RelX, int a_RelZ)
 	
 	if (a_RelZ < 0)
 	{
-		if (m_NeighborZM != NULL)
+		if (m_NeighborZM != nullptr)
 		{
 			return m_NeighborZM->GetRelNeighborChunk(a_RelX, a_RelZ + cChunkDef::Width);
 			// For requests crossing both X and Z, the X-first way has been already tried
 		}
-		return NULL;
+		return nullptr;
 	}
 	else if (a_RelZ >= cChunkDef::Width)
 	{
-		if (m_NeighborZP != NULL)
+		if (m_NeighborZP != nullptr)
 		{
 			return m_NeighborZP->GetRelNeighborChunk(a_RelX, a_RelZ - cChunkDef::Width);
 			// For requests crossing both X and Z, the X-first way has been already tried
 		}
-		return NULL;
+		return nullptr;
 	}
 	
-	return (ReturnThis ? this : NULL);
+	return (ReturnThis ? this : nullptr);
 }
 
 
@@ -2730,27 +2730,27 @@ cChunk * cChunk::GetRelNeighborChunkAdjustCoords(int & a_RelX, int & a_RelZ) con
 	// Request for a different chunk, calculate chunk offset:
 	int RelX = a_RelX;  // Make a local copy of the coords (faster access)
 	int RelZ = a_RelZ;
-	while ((RelX >= Width) && (ToReturn != NULL))
+	while ((RelX >= Width) && (ToReturn != nullptr))
 	{
 		RelX -= Width;
 		ToReturn = ToReturn->m_NeighborXP;
 	}
-	while ((RelX < 0) && (ToReturn != NULL))
+	while ((RelX < 0) && (ToReturn != nullptr))
 	{
 		RelX += Width;
 		ToReturn = ToReturn->m_NeighborXM;
 	}
-	while ((RelZ >= Width) && (ToReturn != NULL))
+	while ((RelZ >= Width) && (ToReturn != nullptr))
 	{
 		RelZ -= Width;
 		ToReturn = ToReturn->m_NeighborZP;
 	}
-	while ((RelZ < 0) && (ToReturn != NULL))
+	while ((RelZ < 0) && (ToReturn != nullptr))
 	{
 		RelZ += Width;
 		ToReturn = ToReturn->m_NeighborZM;
 	}
-	if (ToReturn != NULL)
+	if (ToReturn != nullptr)
 	{
 		a_RelX = RelX;
 		a_RelZ = RelZ;
@@ -2820,7 +2820,7 @@ void cChunk::BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cons
 {
 	// We can operate on entity pointers, we're inside the ChunkMap's CS lock which guards the list
 	cBlockEntity * Entity = GetBlockEntity(a_BlockX, a_BlockY, a_BlockZ);
-	if (Entity == NULL)
+	if (Entity == nullptr)
 	{
 		return;
 	}
@@ -3157,7 +3157,7 @@ void cChunk::BroadcastUseBed(const cEntity & a_Entity, int a_BlockX, int a_Block
 void cChunk::SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client)
 {
 	cBlockEntity * Entity = GetBlockEntity(a_BlockX, a_BlockY, a_BlockZ);
-	if (Entity == NULL)
+	if (Entity == nullptr)
 	{
 		return;
 	}
diff --git a/src/Chunk.h b/src/Chunk.h
index 5f8fcaf7b..6f4ac5cac 100644
--- a/src/Chunk.h
+++ b/src/Chunk.h
@@ -190,13 +190,13 @@ public:
 	void      GetBlockInfo    (int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight);
 	
 	/** Returns the chunk into which the specified block belongs, by walking the neighbors.
-	Will return self if appropriate. Returns NULL if not reachable through neighbors.
+	Will return self if appropriate. Returns nullptr if not reachable through neighbors.
 	*/
 	cChunk * GetNeighborChunk(int a_BlockX, int a_BlockZ);
 	
 	/**
 	Returns the chunk into which the relatively-specified block belongs, by walking the neighbors.
-	Will return self if appropriate. Returns NULL if not reachable through neighbors.
+	Will return self if appropriate. Returns nullptr if not reachable through neighbors.
 	*/
 	cChunk * GetRelNeighborChunk(int a_RelX, int a_RelZ);
 	
@@ -316,28 +316,28 @@ public:
 	// Broadcast various packets to all clients of this chunk:
 	// (Please keep these alpha-sorted)
 	void BroadcastAttachEntity       (const cEntity & a_Entity, const cEntity * a_Vehicle);
-	void BroadcastBlockAction        (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType, const cClientHandle * a_Exclude = NULL);
-	void BroadcastBlockBreakAnimation(int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage, const cClientHandle * a_Exclude = NULL);
-	void BroadcastBlockEntity        (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastChunkData          (cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = NULL);
-	void BroadcastCollectEntity      (const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastDestroyEntity      (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEffect       (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEquipment    (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityHeadLook     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityLook         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityMetadata     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMove      (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMoveLook  (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityStatus       (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityVelocity     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityAnimation    (const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL);
-	void BroadcastParticleEffect     (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude = NULL);
-	void BroadcastRemoveEntityEffect (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
-	void BroadcastSoundEffect        (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);
-	void BroadcastSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL);
-	void BroadcastSpawnEntity        (cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastThunderbolt        (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastBlockAction        (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastBlockBreakAnimation(int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastBlockEntity        (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastChunkData          (cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastCollectEntity      (const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastDestroyEntity      (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityEffect       (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityEquipment    (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityHeadLook     (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityLook         (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityMetadata     (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityRelMove      (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityRelMoveLook  (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityStatus       (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityVelocity     (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityAnimation    (const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastParticleEffect     (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude = nullptr);
+	void BroadcastRemoveEntityEffect (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastSoundEffect        (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastSpawnEntity        (cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastThunderbolt        (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastUseBed             (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ);
 	
 	void SendBlockEntity             (int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client);
diff --git a/src/ChunkData.cpp b/src/ChunkData.cpp
index 03b0224a6..57b27c5e0 100644
--- a/src/ChunkData.cpp
+++ b/src/ChunkData.cpp
@@ -36,7 +36,7 @@ cChunkData::cChunkData(cAllocationPool<cChunkData::sChunkSection> & a_Pool) :
 {
 	for (size_t i = 0; i < NumSections; i++)
 	{
-		m_Sections[i] = NULL;
+		m_Sections[i] = nullptr;
 	}
 }
 
@@ -56,7 +56,7 @@ cChunkData::~cChunkData()
 	for (size_t i = 0; i < NumSections; i++)
 	{
 		Free(m_Sections[i]);
-		m_Sections[i] = NULL;
+		m_Sections[i] = nullptr;
 	}
 }
 
@@ -96,7 +96,7 @@ cChunkData::~cChunkData()
 			for (size_t i = 0; i < NumSections; i++)
 			{
 				Free(m_Sections[i]);
-				m_Sections[i] = NULL;
+				m_Sections[i] = nullptr;
 			}
 		}
 
@@ -120,7 +120,7 @@ cChunkData::~cChunkData()
 		for (size_t i = 0; i < NumSections; i++)
 		{
 			m_Sections[i] = other.m_Sections[i];
-			other.m_Sections[i] = NULL;
+			other.m_Sections[i] = nullptr;
 		}
 	}
 	
@@ -137,7 +137,7 @@ cChunkData::~cChunkData()
 			{
 				Free(m_Sections[i]);
 				m_Sections[i] = other.m_Sections[i];
-				other.m_Sections[i] = NULL;
+				other.m_Sections[i] = nullptr;
 			}
 		}
 		return *this;
@@ -154,7 +154,7 @@ BLOCKTYPE cChunkData::GetBlock(int a_X, int a_Y, int a_Z) const
 	ASSERT((a_Y >= 0) && (a_Y < cChunkDef::Height));
 	ASSERT((a_Z >= 0) && (a_Z < cChunkDef::Width));
 	int Section = a_Y / SectionHeight;
-	if (m_Sections[Section] != NULL)
+	if (m_Sections[Section] != nullptr)
 	{
 		int Index = cChunkDef::MakeIndexNoCheck(a_X, a_Y - (Section * SectionHeight), a_Z);
 		return m_Sections[Section]->m_BlockTypes[Index];
@@ -182,14 +182,14 @@ void cChunkData::SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_Block)
 	}
 
 	int Section = a_RelY / SectionHeight;
-	if (m_Sections[Section] == NULL)
+	if (m_Sections[Section] == nullptr)
 	{
 		if (a_Block == 0x00)
 		{
 			return;
 		}
 		m_Sections[Section] = Allocate();
-		if (m_Sections[Section] == NULL)
+		if (m_Sections[Section] == nullptr)
 		{
 			ASSERT(!"Failed to allocate a new section in Chunkbuffer");
 			return;
@@ -212,7 +212,7 @@ NIBBLETYPE cChunkData::GetMeta(int a_RelX, int a_RelY, int a_RelZ) const
 		(a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 	{
 		int Section = a_RelY / SectionHeight;
-		if (m_Sections[Section] != NULL)
+		if (m_Sections[Section] != nullptr)
 		{
 			int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * SectionHeight), a_RelZ);
 			return (m_Sections[Section]->m_BlockMetas[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
@@ -243,14 +243,14 @@ bool cChunkData::SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Nibble
 	}
 
 	int Section = a_RelY / SectionHeight;
-	if (m_Sections[Section] == NULL)
+	if (m_Sections[Section] == nullptr)
 	{
 		if ((a_Nibble & 0xf) == 0x00)
 		{
 			return false;
 		}
 		m_Sections[Section] = Allocate();
-		if (m_Sections[Section] == NULL)
+		if (m_Sections[Section] == nullptr)
 		{
 			ASSERT(!"Failed to allocate a new section in Chunkbuffer");
 			return false;
@@ -279,7 +279,7 @@ NIBBLETYPE cChunkData::GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const
 	)
 	{
 		int Section = a_RelY / SectionHeight;
-		if (m_Sections[Section] != NULL)
+		if (m_Sections[Section] != nullptr)
 		{
 			int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * SectionHeight), a_RelZ);
 			return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
@@ -302,7 +302,7 @@ NIBBLETYPE cChunkData::GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const
 	if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 	{
 		int Section = a_RelY / SectionHeight;
-		if (m_Sections[Section] != NULL)
+		if (m_Sections[Section] != nullptr)
 		{
 			int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * SectionHeight), a_RelZ);
 			return (m_Sections[Section]->m_BlockSkyLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
@@ -325,7 +325,7 @@ cChunkData cChunkData::Copy(void) const
 	cChunkData copy(m_Pool);
 	for (size_t i = 0; i < NumSections; i++)
 	{
-		if (m_Sections[i] != NULL)
+		if (m_Sections[i] != nullptr)
 		{
 			copy.m_Sections[i] = copy.Allocate();
 			*copy.m_Sections[i] = *m_Sections[i];
@@ -354,7 +354,7 @@ void cChunkData::CopyBlockTypes(BLOCKTYPE * a_Dest, size_t a_Idx, size_t a_Lengt
 		{
 			size_t ToCopy = std::min(+SectionBlockCount - StartPos, a_Length);
 			a_Length -= ToCopy;
-			if (m_Sections[i] != NULL)
+			if (m_Sections[i] != nullptr)
 			{
 				BLOCKTYPE * blockbuffer = m_Sections[i]->m_BlockTypes;
 				memcpy(&a_Dest[(i * SectionBlockCount) + StartPos - a_Idx], blockbuffer + StartPos, sizeof(BLOCKTYPE) * ToCopy);
@@ -375,7 +375,7 @@ void cChunkData::CopyMetas(NIBBLETYPE * a_Dest) const
 {
 	for (size_t i = 0; i < NumSections; i++)
 	{
-		if (m_Sections[i] != NULL)
+		if (m_Sections[i] != nullptr)
 		{
 			memcpy(&a_Dest[i * SectionBlockCount / 2], &m_Sections[i]->m_BlockMetas, sizeof(m_Sections[i]->m_BlockMetas));
 		}
@@ -394,7 +394,7 @@ void cChunkData::CopyBlockLight(NIBBLETYPE * a_Dest) const
 {
 	for (size_t i = 0; i < NumSections; i++)
 	{
-		if (m_Sections[i] != NULL)
+		if (m_Sections[i] != nullptr)
 		{
 			memcpy(&a_Dest[i * SectionBlockCount / 2], &m_Sections[i]->m_BlockLight, sizeof(m_Sections[i]->m_BlockLight));
 		}
@@ -413,7 +413,7 @@ void cChunkData::CopySkyLight(NIBBLETYPE * a_Dest) const
 {
 	for (size_t i = 0; i < NumSections; i++)
 	{
-		if (m_Sections[i] != NULL)
+		if (m_Sections[i] != nullptr)
 		{
 			memcpy(&a_Dest[i * SectionBlockCount / 2], &m_Sections[i]->m_BlockSkyLight, sizeof(m_Sections[i]->m_BlockSkyLight));
 		}
@@ -430,12 +430,12 @@ void cChunkData::CopySkyLight(NIBBLETYPE * a_Dest) const
 
 void cChunkData::SetBlockTypes(const BLOCKTYPE * a_Src)
 {
-	ASSERT(a_Src != NULL);
+	ASSERT(a_Src != nullptr);
 	
 	for (size_t i = 0; i < NumSections; i++)
 	{
 		// If the section is already allocated, copy the data into it:
-		if (m_Sections[i] != NULL)
+		if (m_Sections[i] != nullptr)
 		{
 			memcpy(m_Sections[i]->m_BlockTypes, &a_Src[i * SectionBlockCount], sizeof(m_Sections[i]->m_BlockTypes));
 			continue;
@@ -462,12 +462,12 @@ void cChunkData::SetBlockTypes(const BLOCKTYPE * a_Src)
 
 void cChunkData::SetMetas(const NIBBLETYPE * a_Src)
 {
-	ASSERT(a_Src != NULL);
+	ASSERT(a_Src != nullptr);
 	
 	for (size_t i = 0; i < NumSections; i++)
 	{
 		// If the section is already allocated, copy the data into it:
-		if (m_Sections[i] != NULL)
+		if (m_Sections[i] != nullptr)
 		{
 			memcpy(m_Sections[i]->m_BlockMetas, &a_Src[i * SectionBlockCount / 2], sizeof(m_Sections[i]->m_BlockMetas));
 			continue;
@@ -495,7 +495,7 @@ void cChunkData::SetMetas(const NIBBLETYPE * a_Src)
 
 void cChunkData::SetBlockLight(const NIBBLETYPE * a_Src)
 {
-	if (a_Src == NULL)
+	if (a_Src == nullptr)
 	{
 		return;
 	}
@@ -503,7 +503,7 @@ void cChunkData::SetBlockLight(const NIBBLETYPE * a_Src)
 	for (size_t i = 0; i < NumSections; i++)
 	{
 		// If the section is already allocated, copy the data into it:
-		if (m_Sections[i] != NULL)
+		if (m_Sections[i] != nullptr)
 		{
 			memcpy(m_Sections[i]->m_BlockLight, &a_Src[i * SectionBlockCount / 2], sizeof(m_Sections[i]->m_BlockLight));
 			continue;
@@ -530,7 +530,7 @@ void cChunkData::SetBlockLight(const NIBBLETYPE * a_Src)
 
 void cChunkData::SetSkyLight(const NIBBLETYPE * a_Src)
 {
-	if (a_Src == NULL)
+	if (a_Src == nullptr)
 	{
 		return;
 	}
@@ -538,7 +538,7 @@ void cChunkData::SetSkyLight(const NIBBLETYPE * a_Src)
 	for (size_t i = 0; i < NumSections; i++)
 	{
 		// If the section is already allocated, copy the data into it:
-		if (m_Sections[i] != NULL)
+		if (m_Sections[i] != nullptr)
 		{
 			memcpy(m_Sections[i]->m_BlockSkyLight, &a_Src[i * SectionBlockCount / 2], sizeof(m_Sections[i]->m_BlockSkyLight));
 			continue;
diff --git a/src/ChunkData.h b/src/ChunkData.h
index fe8b068a2..2ab629b29 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -88,12 +88,12 @@ public:
 
 	/** Copies the blocklight data from the specified flat array into the internal representation.
 	Allocates sectios that are needed for the operation.
-	Allows a_Src to be NULL, in which case it doesn't do anything. */
+	Allows a_Src to be nullptr, in which case it doesn't do anything. */
 	void SetBlockLight(const NIBBLETYPE * a_Src);
 
 	/** Copies the skylight data from the specified flat array into the internal representation.
 	Allocates sectios that are needed for the operation.
-	Allows a_Src to be NULL, in which case it doesn't do anything. */
+	Allows a_Src to be nullptr, in which case it doesn't do anything. */
 	void SetSkyLight(const NIBBLETYPE * a_Src);
 
 	struct sChunkSection
@@ -118,7 +118,7 @@ private:
 	sChunkSection * Allocate(void);
 
 	/** Frees the specified section, previously allocated using Allocate().
-	Note that a_Section may be NULL. */
+	Note that a_Section may be nullptr. */
 	void Free(sChunkSection * a_Section);
 	
 	/** Sets the data in the specified section to their default values. */
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index 6f56b23e0..595040a54 100644
--- a/src/ChunkMap.cpp
+++ b/src/ChunkMap.cpp
@@ -88,10 +88,10 @@ cChunkMap::cChunkLayer * cChunkMap::GetLayer(int a_LayerX, int a_LayerZ)
 	
 	// Not found, create new:
 	cChunkLayer * Layer = new cChunkLayer(a_LayerX, a_LayerZ, this, *m_Pool);
-	if (Layer == NULL)
+	if (Layer == nullptr)
 	{
 		LOGERROR("cChunkMap: Cannot create new layer, server out of memory?");
-		return NULL;
+		return nullptr;
 	}
 	m_Layers.push_back(Layer);
 	return Layer;
@@ -125,7 +125,7 @@ cChunkMap::cChunkLayer * cChunkMap::FindLayer(int a_LayerX, int a_LayerZ)
 	}  // for itr - m_Layers[]
 	
 	// Not found
-	return NULL;
+	return nullptr;
 }
 
 
@@ -148,16 +148,16 @@ cChunkPtr cChunkMap::GetChunk(int a_ChunkX, int a_ChunkZ)
 	ASSERT(m_CSLayers.IsLockedByCurrentThread());  // m_CSLayers should already be locked by the operation that called us
 
 	cChunkLayer * Layer = GetLayerForChunk(a_ChunkX, a_ChunkZ);
-	if (Layer == NULL)
+	if (Layer == nullptr)
 	{
 		// An error must have occurred, since layers are automatically created if they don't exist
-		return NULL;
+		return nullptr;
 	}
 	
 	cChunkPtr Chunk = Layer->GetChunk(a_ChunkX, a_ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
-		return NULL;
+		return nullptr;
 	}
 	if (!Chunk->IsValid() && !Chunk->IsQueued())
 	{
@@ -177,16 +177,16 @@ cChunkPtr cChunkMap::GetChunkNoGen(int a_ChunkX, int a_ChunkZ)
 	ASSERT(m_CSLayers.IsLockedByCurrentThread());  // m_CSLayers should already be locked by the operation that called us
 
 	cChunkLayer * Layer = GetLayerForChunk(a_ChunkX, a_ChunkZ);
-	if (Layer == NULL)
+	if (Layer == nullptr)
 	{
 		// An error must have occurred, since layers are automatically created if they don't exist
-		return NULL;
+		return nullptr;
 	}
 	
 	cChunkPtr Chunk = Layer->GetChunk(a_ChunkX, a_ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
-		return NULL;
+		return nullptr;
 	}
 	if (!Chunk->IsValid() && !Chunk->IsQueued())
 	{
@@ -206,10 +206,10 @@ cChunkPtr cChunkMap::GetChunkNoLoad( int a_ChunkX, int a_ChunkZ)
 	ASSERT(m_CSLayers.IsLockedByCurrentThread());  // m_CSLayers should already be locked by the operation that called us
 
 	cChunkLayer * Layer = GetLayerForChunk( a_ChunkX, a_ChunkZ);
-	if (Layer == NULL)
+	if (Layer == nullptr)
 	{
 		// An error must have occurred, since layers are automatically created if they don't exist
-		return NULL;
+		return nullptr;
 	}
 	
 	return Layer->GetChunk(a_ChunkX, a_ChunkZ);
@@ -227,7 +227,7 @@ bool cChunkMap::LockedGetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTY
 	int ChunkX, ChunkZ;
 	cChunkDef::AbsoluteToRelative(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return false;
 	}
@@ -249,7 +249,7 @@ bool cChunkMap::LockedGetBlockType(int a_BlockX, int a_BlockY, int a_BlockZ, BLO
 	int ChunkX, ChunkZ;
 	cChunkDef::AbsoluteToRelative(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return false;
 	}
@@ -270,7 +270,7 @@ bool cChunkMap::LockedGetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIB
 	int ChunkX, ChunkZ;
 	cChunkDef::AbsoluteToRelative(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return false;
 	}
@@ -289,7 +289,7 @@ bool cChunkMap::LockedSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTY
 	int ChunkX, ChunkZ;
 	cChunkDef::AbsoluteToRelative(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return false;
 	}
@@ -308,7 +308,7 @@ bool cChunkMap::LockedFastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLO
 	int ChunkX, ChunkZ;
 	cChunkDef::AbsoluteToRelative(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return false;
 	}
@@ -326,9 +326,9 @@ cChunk * cChunkMap::FindChunk(int a_ChunkX, int a_ChunkZ)
 	ASSERT(m_CSLayers.IsLockedByCurrentThread());
 	
 	cChunkLayer * Layer = FindLayerForChunk(a_ChunkX, a_ChunkZ);
-	if (Layer == NULL)
+	if (Layer == nullptr)
 	{
-		return NULL;
+		return nullptr;
 	}
 	return Layer->FindChunk(a_ChunkX, a_ChunkZ);
 }
@@ -341,7 +341,7 @@ void cChunkMap::BroadcastAttachEntity(const cEntity & a_Entity, const cEntity *
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -361,7 +361,7 @@ void cChunkMap::BroadcastBlockAction(int a_BlockX, int a_BlockY, int a_BlockZ, c
 	z = a_BlockZ;
 	cChunkDef::BlockToChunk(x, z, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -380,7 +380,7 @@ void cChunkMap::BroadcastBlockBreakAnimation(int a_entityID, int a_blockX, int a
 
 	cChunkDef::BlockToChunk(a_blockX, a_blockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -398,7 +398,7 @@ void cChunkMap::BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, c
 	int ChunkX, ChunkZ;
 	cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return;
 	}
@@ -413,7 +413,7 @@ void cChunkMap::BroadcastChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSeriali
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -429,7 +429,7 @@ void cChunkMap::BroadcastCollectEntity(const cEntity & a_Entity, const cPlayer &
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -445,7 +445,7 @@ void cChunkMap::BroadcastDestroyEntity(const cEntity & a_Entity, const cClientHa
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -461,7 +461,7 @@ void cChunkMap::BroadcastEntityEffect(const cEntity & a_Entity, int a_EffectID,
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -477,7 +477,7 @@ void cChunkMap::BroadcastEntityEquipment(const cEntity & a_Entity, short a_SlotN
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -493,7 +493,7 @@ void cChunkMap::BroadcastEntityHeadLook(const cEntity & a_Entity, const cClientH
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -509,7 +509,7 @@ void cChunkMap::BroadcastEntityLook(const cEntity & a_Entity, const cClientHandl
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -525,7 +525,7 @@ void cChunkMap::BroadcastEntityMetadata(const cEntity & a_Entity, const cClientH
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -541,7 +541,7 @@ void cChunkMap::BroadcastEntityRelMove(const cEntity & a_Entity, char a_RelX, ch
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -557,7 +557,7 @@ void cChunkMap::BroadcastEntityRelMoveLook(const cEntity & a_Entity, char a_RelX
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -573,7 +573,7 @@ void cChunkMap::BroadcastEntityStatus(const cEntity & a_Entity, char a_Status, c
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -589,7 +589,7 @@ void cChunkMap::BroadcastEntityVelocity(const cEntity & a_Entity, const cClientH
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -605,7 +605,7 @@ void cChunkMap::BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animat
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -624,7 +624,7 @@ void cChunkMap::BroadcastParticleEffect(const AString & a_ParticleName, float a_
 
 	cChunkDef::BlockToChunk((int) a_SrcX, (int) a_SrcZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -641,7 +641,7 @@ void cChunkMap::BroadcastRemoveEntityEffect(const cEntity & a_Entity, int a_Effe
 	cCSLock Lock(m_CSLayers);
 	
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -660,7 +660,7 @@ void cChunkMap::BroadcastSoundEffect(const AString & a_SoundName, double a_X, do
 
 	cChunkDef::BlockToChunk((int)std::floor(a_X), (int)std::floor(a_Z), ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -679,7 +679,7 @@ void cChunkMap::BroadcastSoundParticleEffect(int a_EffectID, int a_SrcX, int a_S
 
 	cChunkDef::BlockToChunk(a_SrcX, a_SrcZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -695,7 +695,7 @@ void cChunkMap::BroadcastSpawnEntity(cEntity & a_Entity, const cClientHandle * a
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkZ());
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -713,7 +713,7 @@ void cChunkMap::BroadcastThunderbolt(int a_BlockX, int a_BlockY, int a_BlockZ, c
 	int ChunkX, ChunkZ;
 	cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -732,7 +732,7 @@ void cChunkMap::BroadcastUseBed(const cEntity & a_Entity, int a_BlockX, int a_Bl
 
 	cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -750,7 +750,7 @@ void cChunkMap::SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClien
 	int ChunkX, ChunkZ;
 	cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return;
 	}
@@ -768,7 +768,7 @@ void cChunkMap::UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, i
 	int ChunkX, ChunkZ;
 	cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return;
 	}
@@ -783,7 +783,7 @@ bool cChunkMap::DoWithChunk(int a_ChunkX, int a_ChunkZ, cChunkCallback & a_Callb
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(a_ChunkX, a_ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return false;
 	}
@@ -800,7 +800,7 @@ void cChunkMap::WakeUpSimulators(int a_BlockX, int a_BlockY, int a_BlockZ)
 	int ChunkX, ChunkZ;
 	cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return;
 	}
@@ -829,7 +829,7 @@ void cChunkMap::WakeUpSimulatorsInArea(int a_MinBlockX, int a_MaxBlockX, int a_M
 		for (int x = MinChunkX; x <= MaxChunkX; x++)
 		{
 			cChunkPtr Chunk = GetChunkNoGen(x, z);
-			if ((Chunk == NULL) || !Chunk->IsValid())
+			if ((Chunk == nullptr) || !Chunk->IsValid())
 			{
 				continue;
 			}
@@ -857,7 +857,7 @@ void cChunkMap::MarkRedstoneDirty(int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return;
 	}
@@ -872,7 +872,7 @@ void cChunkMap::MarkChunkDirty(int a_ChunkX, int a_ChunkZ, bool a_MarkRedstoneDi
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return;
 	}
@@ -891,7 +891,7 @@ void cChunkMap::MarkChunkSaving(int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return;
 	}
@@ -906,7 +906,7 @@ void cChunkMap::MarkChunkSaved (int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return;
 	}
@@ -924,7 +924,7 @@ void cChunkMap::SetChunkData(cSetChunkData & a_SetChunkData)
 	{
 		cCSLock Lock(m_CSLayers);
 		cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-		if (Chunk == NULL)
+		if (Chunk == nullptr)
 		{
 			return;
 		}
@@ -969,7 +969,7 @@ void cChunkMap::ChunkLighted(
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(a_ChunkX, a_ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -985,7 +985,7 @@ bool cChunkMap::GetChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataCallback & a_
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -1001,7 +1001,7 @@ bool cChunkMap::GetChunkBlockTypes(int a_ChunkX, int a_ChunkZ, BLOCKTYPE * a_Blo
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -1017,7 +1017,7 @@ bool cChunkMap::IsChunkQueued(int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(a_ChunkX, a_ChunkZ);
-	return (Chunk != NULL) && Chunk->IsQueued();
+	return (Chunk != nullptr) && Chunk->IsQueued();
 }
 
 
@@ -1028,7 +1028,7 @@ bool cChunkMap::IsChunkValid(int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(a_ChunkX, a_ChunkZ);
-	return (Chunk != NULL) && Chunk->IsValid();
+	return (Chunk != nullptr) && Chunk->IsValid();
 }
 
 
@@ -1039,7 +1039,7 @@ bool cChunkMap::HasChunkAnyClients(int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	return (Chunk != NULL) && Chunk->HasAnyClients();
+	return (Chunk != nullptr) && Chunk->HasAnyClients();
 }
 
 
@@ -1054,7 +1054,7 @@ int  cChunkMap::GetHeight(int a_BlockX, int a_BlockZ)
 		int ChunkX, ChunkZ, BlockY = 0;
 		cChunkDef::AbsoluteToRelative(a_BlockX, BlockY, a_BlockZ, ChunkX, ChunkZ);
 		cChunkPtr Chunk = GetChunk(ChunkX, ChunkZ);
-		if (Chunk == NULL)
+		if (Chunk == nullptr)
 		{
 			return 0;
 		}
@@ -1081,7 +1081,7 @@ bool cChunkMap::TryGetHeight(int a_BlockX, int a_BlockZ, int & a_Height)
 	int ChunkX, ChunkZ, BlockY = 0;
 	cChunkDef::AbsoluteToRelative(a_BlockX, BlockY, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -1104,7 +1104,7 @@ void cChunkMap::FastSetBlocks(sSetBlockList & a_BlockList)
 		int ChunkZ = a_BlockList.front().ChunkZ;
 		cCSLock Lock(m_CSLayers);
 		cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-		if ((Chunk != NULL) && Chunk->IsValid())
+		if ((Chunk != nullptr) && Chunk->IsValid())
 		{
 			for (sSetBlockList::iterator itr = a_BlockList.begin(); itr != a_BlockList.end();)
 			{
@@ -1193,7 +1193,7 @@ BLOCKTYPE cChunkMap::GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
 	
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk(ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		return Chunk->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
 	}
@@ -1222,7 +1222,7 @@ NIBBLETYPE cChunkMap::GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ)
 	
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk( ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		return Chunk->GetMeta(a_BlockX, a_BlockY, a_BlockZ);
 	}
@@ -1240,7 +1240,7 @@ NIBBLETYPE cChunkMap::GetBlockSkyLight(int a_BlockX, int a_BlockY, int a_BlockZ)
 
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk( ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		return Chunk->GetSkyLight(a_BlockX, a_BlockY, a_BlockZ);
 	}
@@ -1258,7 +1258,7 @@ NIBBLETYPE cChunkMap::GetBlockBlockLight(int a_BlockX, int a_BlockY, int a_Block
 
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk( ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		return Chunk->GetBlockLight(a_BlockX, a_BlockY, a_BlockZ);
 	}
@@ -1277,7 +1277,7 @@ void cChunkMap::SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYP
 
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk(ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		Chunk->SetMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockMeta);
 	}
@@ -1300,7 +1300,7 @@ void cChunkMap::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_B
 
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk( ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		Chunk->SetBlock(X, Y, Z, a_BlockType, a_BlockMeta, a_SendToClients);
 		m_World->GetSimulatorManager()->WakeUp(a_BlockX, a_BlockY, a_BlockZ, Chunk);
@@ -1319,7 +1319,7 @@ void cChunkMap::QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYP
 
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk(ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		Chunk->QueueSetBlock(X, Y, Z, a_BlockType, a_BlockMeta, a_Tick, a_PreviousBlockType);
 	}
@@ -1336,7 +1336,7 @@ bool cChunkMap::GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCK
 
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk( ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		Chunk->GetBlockTypeMeta(X, Y, Z, a_BlockType, a_BlockMeta);
 		return true;
@@ -1355,7 +1355,7 @@ bool cChunkMap::GetBlockInfo(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE
 
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk( ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		Chunk->GetBlockInfo(X, Y, Z, a_BlockType, a_Meta, a_SkyLight, a_BlockLight);
 		return true;
@@ -1373,7 +1373,7 @@ void cChunkMap::ReplaceBlocks(const sSetBlockVector & a_Blocks, BLOCKTYPE a_Filt
 	for (sSetBlockVector::const_iterator itr = a_Blocks.begin(); itr != a_Blocks.end(); ++itr)
 	{
 		cChunkPtr Chunk = GetChunk(itr->ChunkX, itr->ChunkZ);
-		if ((Chunk == NULL) || !Chunk->IsValid())
+		if ((Chunk == nullptr) || !Chunk->IsValid())
 		{
 			continue;
 		}
@@ -1394,7 +1394,7 @@ void cChunkMap::ReplaceTreeBlocks(const sSetBlockVector & a_Blocks)
 	for (sSetBlockVector::const_iterator itr = a_Blocks.begin(); itr != a_Blocks.end(); ++itr)
 	{
 		cChunkPtr Chunk = GetChunk(itr->ChunkX, itr->ChunkZ);
-		if ((Chunk == NULL) || !Chunk->IsValid())
+		if ((Chunk == nullptr) || !Chunk->IsValid())
 		{
 			continue;
 		}
@@ -1429,7 +1429,7 @@ EMCSBiome cChunkMap::GetBiomeAt (int a_BlockX, int a_BlockZ)
 
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk(ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		return Chunk->GetBiomeAt(X, Z);
 	}
@@ -1450,7 +1450,7 @@ bool cChunkMap::SetBiomeAt(int a_BlockX, int a_BlockZ, EMCSBiome a_Biome)
 
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk(ChunkX, ChunkZ);
-	if ((Chunk != NULL) && Chunk->IsValid())
+	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
 		Chunk->SetBiomeAt(X, Z, a_Biome);
 		return true;
@@ -1483,7 +1483,7 @@ bool cChunkMap::SetAreaBiome(int a_MinX, int a_MaxX, int a_MinZ, int a_MaxZ, EMC
 			int MinRelZ = (z == MinChunkZ) ? MinZ : 0;
 			int MaxRelZ = (z == MaxChunkZ) ? MaxZ : cChunkDef::Width - 1;
 			cChunkPtr Chunk = GetChunkNoLoad(x, z);
-			if ((Chunk != NULL) && Chunk->IsValid())
+			if ((Chunk != nullptr) && Chunk->IsValid())
 			{
 				Chunk->SetAreaBiome(MinRelX, MaxRelX, MinRelZ, MaxRelZ, a_Biome);
 			}
@@ -1507,7 +1507,7 @@ bool cChunkMap::GetBlocks(sSetBlockVector & a_Blocks, bool a_ContinueOnFailure)
 	for (sSetBlockVector::iterator itr = a_Blocks.begin(); itr != a_Blocks.end(); ++itr)
 	{
 		cChunkPtr Chunk = GetChunk(itr->ChunkX, itr->ChunkZ);
-		if ((Chunk == NULL) || !Chunk->IsValid())
+		if ((Chunk == nullptr) || !Chunk->IsValid())
 		{
 			if (!a_ContinueOnFailure)
 			{
@@ -1535,7 +1535,7 @@ bool cChunkMap::DigBlock(int a_X, int a_Y, int a_Z)
 	{
 		cCSLock Lock(m_CSLayers);
 		cChunkPtr DestChunk = GetChunk( ChunkX, ChunkZ);
-		if ((DestChunk == NULL) || !DestChunk->IsValid())
+		if ((DestChunk == nullptr) || !DestChunk->IsValid())
 		{
 			return false;
 		}
@@ -1558,7 +1558,7 @@ void cChunkMap::SendBlockTo(int a_X, int a_Y, int a_Z, cPlayer * a_Player)
 	
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk(ChunkX, ChunkZ);
-	if ((Chunk != NULL) && (Chunk->IsValid()))
+	if ((Chunk != nullptr) && (Chunk->IsValid()))
 	{
 		Chunk->SendBlockTo(a_X, a_Y, a_Z, a_Player->GetClientHandle());
 	}
@@ -1572,12 +1572,12 @@ void cChunkMap::CompareChunkClients(int a_ChunkX1, int a_ChunkZ1, int a_ChunkX2,
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk1 = GetChunkNoGen(a_ChunkX1, a_ChunkZ1);
-	if (Chunk1 == NULL)
+	if (Chunk1 == nullptr)
 	{
 		return;
 	}
 	cChunkPtr Chunk2 = GetChunkNoGen(a_ChunkX2, a_ChunkZ2);
-	if (Chunk2 == NULL)
+	if (Chunk2 == nullptr)
 	{
 		return;
 	}
@@ -1639,7 +1639,7 @@ bool cChunkMap::AddChunkClient(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Cli
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunk(a_ChunkX, a_ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return false;
 	}
@@ -1654,7 +1654,7 @@ void cChunkMap::RemoveChunkClient(int a_ChunkX, int a_ChunkZ, cClientHandle * a_
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -1684,7 +1684,7 @@ void cChunkMap::AddEntity(cEntity * a_Entity)
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity->GetChunkX(), a_Entity->GetChunkZ());
 	if (
-		(Chunk == NULL) ||  // Chunk not present at all
+		(Chunk == nullptr) ||  // Chunk not present at all
 		(!Chunk->IsValid() && !a_Entity->IsPlayer())  // Chunk present, but no valid data; players need to spawn in such chunks (#953)
 	)
 	{
@@ -1705,7 +1705,7 @@ void cChunkMap::AddEntityIfNotPresent(cEntity * a_Entity)
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity->GetChunkX(), a_Entity->GetChunkZ());
 	if (
-		(Chunk == NULL) ||  // Chunk not present at all
+		(Chunk == nullptr) ||  // Chunk not present at all
 		(!Chunk->IsValid() && !a_Entity->IsPlayer())  // Chunk present, but no valid data; players need to spawn in such chunks (#953)
 	)
 	{
@@ -1747,7 +1747,7 @@ void cChunkMap::RemoveEntity(cEntity * a_Entity)
 	cChunkPtr Chunk = GetChunkNoGen(a_Entity->GetChunkX(), a_Entity->GetChunkZ());
 
 	// Even if a chunk is not valid, it may still contain entities such as players; make sure to remove them (#1190)
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -1779,7 +1779,7 @@ bool cChunkMap::ForEachEntityInChunk(int a_ChunkX, int a_ChunkZ, cEntityCallback
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -1805,7 +1805,7 @@ bool cChunkMap::ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback &
 		for (int x = MinChunkX; x <= MaxChunkX; x++)
 		{
 			cChunkPtr Chunk = GetChunkNoGen(x, z);
-			if ((Chunk == NULL) || !Chunk->IsValid())
+			if ((Chunk == nullptr) || !Chunk->IsValid())
 			{
 				continue;
 			}
@@ -1980,7 +1980,7 @@ void cChunkMap::DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_
 				}
 
 				// Ensure that the damage dealt is inversely proportional to the distance to the TNT centre - the closer a player is, the harder they are hit
-				a_Entity->TakeDamage(dtExplosion, NULL, (int)((1 / DistanceFromExplosion.Length()) * 6 * m_ExplosionSize), 0);
+				a_Entity->TakeDamage(dtExplosion, nullptr, (int)((1 / DistanceFromExplosion.Length()) * 6 * m_ExplosionSize), 0);
 			}
 
 			// Apply force to entities around the explosion - code modified from World.cpp DoExplosionAt()
@@ -2038,7 +2038,7 @@ bool cChunkMap::ForEachBlockEntityInChunk(int a_ChunkX, int a_ChunkZ, cBlockEnti
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2053,7 +2053,7 @@ bool cChunkMap::ForEachChestInChunk(int a_ChunkX, int a_ChunkZ, cChestCallback &
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2068,7 +2068,7 @@ bool cChunkMap::ForEachDispenserInChunk(int a_ChunkX, int a_ChunkZ, cDispenserCa
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2083,7 +2083,7 @@ bool cChunkMap::ForEachDropperInChunk(int a_ChunkX, int a_ChunkZ, cDropperCallba
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2098,7 +2098,7 @@ bool cChunkMap::ForEachDropSpenserInChunk(int a_ChunkX, int a_ChunkZ, cDropSpens
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2113,7 +2113,7 @@ bool cChunkMap::ForEachFurnaceInChunk(int a_ChunkX, int a_ChunkZ, cFurnaceCallba
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2131,7 +2131,7 @@ bool cChunkMap::DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cB
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2149,7 +2149,7 @@ bool cChunkMap::DoWithBeaconAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBeacon
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2167,7 +2167,7 @@ bool cChunkMap::DoWithChestAt(int a_BlockX, int a_BlockY, int a_BlockZ, cChestCa
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2185,7 +2185,7 @@ bool cChunkMap::DoWithDispenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDis
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2203,7 +2203,7 @@ bool cChunkMap::DoWithDropperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropp
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2221,7 +2221,7 @@ bool cChunkMap::DoWithDropSpenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cD
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2239,7 +2239,7 @@ bool cChunkMap::DoWithFurnaceAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFurna
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2256,7 +2256,7 @@ bool cChunkMap::DoWithNoteBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cNot
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2273,7 +2273,7 @@ bool cChunkMap::DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, c
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2291,7 +2291,7 @@ bool cChunkMap::DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHe
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2309,7 +2309,7 @@ bool cChunkMap::DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlo
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2327,7 +2327,7 @@ bool cChunkMap::GetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, AString &
 	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2352,7 +2352,7 @@ void cChunkMap::ChunkLoadFailed(int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(a_ChunkX, a_ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		return;
 	}
@@ -2369,7 +2369,7 @@ bool cChunkMap::SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const ASt
 	int ChunkX, ChunkZ;
 	cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
@@ -2384,7 +2384,7 @@ void cChunkMap::MarkChunkRegenerating(int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(a_ChunkX, a_ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		// Not present
 		return;
@@ -2400,7 +2400,7 @@ bool cChunkMap::IsChunkLighted(int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(a_ChunkX, a_ChunkZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		// Not present
 		return false;
@@ -2421,7 +2421,7 @@ bool cChunkMap::ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinCh
 		for (int x = a_MinChunkX; x <= a_MaxChunkX; x++)
 		{
 			cChunkPtr Chunk = GetChunkNoLoad(x, z);
-			if ((Chunk == NULL) || (!Chunk->IsValid()))
+			if ((Chunk == nullptr) || (!Chunk->IsValid()))
 			{
 				// Not present / not valid
 				Result = false;
@@ -2463,7 +2463,7 @@ bool cChunkMap::WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBl
 		for (int x = MinChunkX; x <= MaxChunkX; x++)
 		{
 			cChunkPtr Chunk = GetChunkNoLoad(x, z);
-			if ((Chunk == NULL) || (!Chunk->IsValid()))
+			if ((Chunk == nullptr) || (!Chunk->IsValid()))
 			{
 				// Not present / not valid
 				Result = false;
@@ -2504,7 +2504,7 @@ void cChunkMap::GrowMelonPumpkin(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCK
 	
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if (Chunk != NULL)
+	if (Chunk != nullptr)
 	{
 		Chunk->GrowMelonPumpkin(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_Rand);
 	}
@@ -2521,7 +2521,7 @@ void cChunkMap::GrowSugarcane(int a_BlockX, int a_BlockY, int a_BlockZ, int a_Nu
 	
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if (Chunk != NULL)
+	if (Chunk != nullptr)
 	{
 		Chunk->GrowSugarcane(a_BlockX, a_BlockY, a_BlockZ, a_NumBlocksToGrow);
 	}
@@ -2538,7 +2538,7 @@ void cChunkMap::GrowCactus(int a_BlockX, int a_BlockY, int a_BlockZ, int a_NumBl
 	
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if (Chunk != NULL)
+	if (Chunk != nullptr)
 	{
 		Chunk->GrowCactus(a_BlockX, a_BlockY, a_BlockZ, a_NumBlocksToGrow);
 	}
@@ -2555,7 +2555,7 @@ void cChunkMap::SetNextBlockTick(int a_BlockX, int a_BlockY, int a_BlockZ)
 	
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if (Chunk != NULL)
+	if (Chunk != nullptr)
 	{
 		Chunk->SetNextBlockTick(a_BlockX, a_BlockY, a_BlockZ);
 	}
@@ -2610,7 +2610,7 @@ void cChunkMap::TickBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
 	int ChunkX, ChunkZ;
 	cChunkDef::AbsoluteToRelative(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if ((Chunk == NULL) || !Chunk->IsValid())
+	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return;
 	}
@@ -2679,7 +2679,7 @@ void cChunkMap::QueueTickBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
 
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(ChunkX, ChunkZ);
-	if (Chunk != NULL)
+	if (Chunk != nullptr)
 	{
 		Chunk->QueueTickBlock(a_BlockX, a_BlockY, a_BlockZ);
 	}
@@ -2693,7 +2693,7 @@ void cChunkMap::SetChunkAlwaysTicked(int a_ChunkX, int a_ChunkZ, bool a_AlwaysTi
 {
 	cCSLock Lock(m_CSLayers);
 	cChunkPtr Chunk = GetChunkNoLoad(a_ChunkX, a_ChunkZ);
-	if (Chunk != NULL)
+	if (Chunk != nullptr)
 	{
 		Chunk->SetAlwaysTicked(a_AlwaysTicked);
 	}
@@ -2729,7 +2729,7 @@ cChunkMap::cChunkLayer::~cChunkLayer()
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); ++i)
 	{
 		delete m_Chunks[i];
-		m_Chunks[i] = NULL;  // Must zero out, because further chunk deletions query the chunkmap for entities and that would touch deleted data
+		m_Chunks[i] = nullptr;  // Must zero out, because further chunk deletions query the chunkmap for entities and that would touch deleted data
 	}  // for i - m_Chunks[]
 }
 
@@ -2747,11 +2747,11 @@ cChunkPtr cChunkMap::cChunkLayer::GetChunk( int a_ChunkX, int a_ChunkZ)
 	if (!((LocalX < LAYER_SIZE) && (LocalZ < LAYER_SIZE) && (LocalX > -1) && (LocalZ > -1)))
 	{
 		ASSERT(!"Asking a cChunkLayer for a chunk that doesn't belong to it!");
-		return NULL;
+		return nullptr;
 	}
 	
 	int Index = LocalX + LocalZ * LAYER_SIZE;
-	if (m_Chunks[Index] == NULL)
+	if (m_Chunks[Index] == nullptr)
 	{
 		cChunk * neixm = (LocalX > 0)              ? m_Chunks[Index - 1]          : m_Parent->FindChunk(a_ChunkX - 1, a_ChunkZ);
 		cChunk * neixp = (LocalX < LAYER_SIZE - 1) ? m_Chunks[Index + 1]          : m_Parent->FindChunk(a_ChunkX + 1, a_ChunkZ);
@@ -2774,7 +2774,7 @@ cChunk * cChunkMap::cChunkLayer::FindChunk(int a_ChunkX, int a_ChunkZ)
 	if (!((LocalX < LAYER_SIZE) && (LocalZ < LAYER_SIZE) && (LocalX > -1) && (LocalZ > -1)))
 	{
 		ASSERT(!"Asking a cChunkLayer for a chunk that doesn't belong to it!");
-		return NULL;
+		return nullptr;
 	}
 	
 	int Index = LocalX + LocalZ * LAYER_SIZE;
@@ -2791,7 +2791,7 @@ void cChunkMap::cChunkLayer::CollectMobCensus(cMobCensus& a_ToFill)
 		// We do count every Mobs in the world. But we are assuming that every chunk not loaded by any client
 		// doesn't affect us. Normally they should not have mobs because every "too far" mobs despawn
 		// If they have (f.i. when player disconnect) we assume we don't have to make them live or despawn
-		if ((m_Chunks[i] != NULL) && m_Chunks[i]->IsValid() && m_Chunks[i]->HasAnyClients())
+		if ((m_Chunks[i] != nullptr) && m_Chunks[i]->IsValid() && m_Chunks[i]->HasAnyClients())
 		{
 			m_Chunks[i]->CollectMobCensus(a_ToFill);
 		}
@@ -2808,7 +2808,7 @@ void cChunkMap::cChunkLayer::SpawnMobs(cMobSpawner& a_MobSpawner)
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); i++)
 	{
 		// We only spawn close to players
-		if ((m_Chunks[i] != NULL) && m_Chunks[i]->IsValid() && m_Chunks[i]->HasAnyClients())
+		if ((m_Chunks[i] != nullptr) && m_Chunks[i]->IsValid() && m_Chunks[i]->HasAnyClients())
 		{
 			m_Chunks[i]->SpawnMobs(a_MobSpawner);
 		}
@@ -2824,7 +2824,7 @@ void cChunkMap::cChunkLayer::Tick(float a_Dt)
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); i++)
 	{
 		// Only tick chunks that are valid and should be ticked:
-		if ((m_Chunks[i] != NULL) && m_Chunks[i]->IsValid() && m_Chunks[i]->ShouldBeTicked())
+		if ((m_Chunks[i] != nullptr) && m_Chunks[i]->IsValid() && m_Chunks[i]->ShouldBeTicked())
 		{
 			m_Chunks[i]->Tick(a_Dt);
 		}
@@ -2839,7 +2839,7 @@ void cChunkMap::cChunkLayer::RemoveClient(cClientHandle * a_Client)
 {
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); i++)
 	{
-		if (m_Chunks[i] != NULL)
+		if (m_Chunks[i] != nullptr)
 		{
 			m_Chunks[i]->RemoveClient(a_Client);
 		}
@@ -2855,7 +2855,7 @@ bool cChunkMap::cChunkLayer::ForEachEntity(cEntityCallback & a_Callback)
 	// Calls the callback for each entity in the entire world; returns true if all entities processed, false if the callback aborted by returning true
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); i++)
 	{
-		if ((m_Chunks[i] != NULL) && m_Chunks[i]->IsValid())
+		if ((m_Chunks[i] != nullptr) && m_Chunks[i]->IsValid())
 		{
 			if (!m_Chunks[i]->ForEachEntity(a_Callback))
 			{
@@ -2875,7 +2875,7 @@ bool cChunkMap::cChunkLayer::DoWithEntityByID(int a_EntityID, cEntityCallback &
 	// Calls the callback if the entity with the specified ID is found, with the entity object as the callback param. Returns true if entity found.
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); i++)
 	{
-		if ((m_Chunks[i] != NULL) && m_Chunks[i]->IsValid())
+		if ((m_Chunks[i] != nullptr) && m_Chunks[i]->IsValid())
 		{
 			if (m_Chunks[i]->DoWithEntityByID(a_EntityID, a_Callback, a_CallbackReturn))
 			{
@@ -2894,7 +2894,7 @@ bool cChunkMap::cChunkLayer::HasEntity(int a_EntityID)
 {
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); i++)
 	{
-		if ((m_Chunks[i] != NULL) && m_Chunks[i]->IsValid())
+		if ((m_Chunks[i] != nullptr) && m_Chunks[i]->IsValid())
 		{
 			if (m_Chunks[i]->HasEntity(a_EntityID))
 			{
@@ -2914,7 +2914,7 @@ int cChunkMap::cChunkLayer::GetNumChunksLoaded(void) const
 	int NumChunks = 0;
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); ++i)
 	{
-		if (m_Chunks[i] != NULL)
+		if (m_Chunks[i] != nullptr)
 		{
 			NumChunks++;
 		}
@@ -2932,7 +2932,7 @@ void cChunkMap::cChunkLayer::GetChunkStats(int & a_NumChunksValid, int & a_NumCh
 	int NumDirty = 0;
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); ++i)
 	{
-		if (m_Chunks[i] == NULL)
+		if (m_Chunks[i] == nullptr)
 		{
 			continue;
 		}
@@ -2955,7 +2955,7 @@ void cChunkMap::cChunkLayer::Save(void)
 	cWorld * World = m_Parent->GetWorld();
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); ++i)
 	{
-		if ((m_Chunks[i] != NULL) && m_Chunks[i]->IsValid() && m_Chunks[i]->IsDirty())
+		if ((m_Chunks[i] != nullptr) && m_Chunks[i]->IsValid() && m_Chunks[i]->IsDirty())
 		{
 			World->GetStorage().QueueSaveChunk(m_Chunks[i]->GetPosX(), m_Chunks[i]->GetPosZ());
 		}
@@ -2971,7 +2971,7 @@ void cChunkMap::cChunkLayer::UnloadUnusedChunks(void)
 	for (size_t i = 0; i < ARRAYCOUNT(m_Chunks); i++)
 	{
 		if (
-			(m_Chunks[i] != NULL) &&   // Is valid
+			(m_Chunks[i] != nullptr) &&   // Is valid
 			(m_Chunks[i]->CanUnload()) &&  // Can unload
 			!cPluginManager::Get()->CallHookChunkUnloading(*(m_Parent->GetWorld()), m_Chunks[i]->GetPosX(), m_Chunks[i]->GetPosZ())  // Plugins agree
 		)
@@ -2980,7 +2980,7 @@ void cChunkMap::cChunkLayer::UnloadUnusedChunks(void)
 			// so we still need to be able to return the chunk. Therefore we first delete, then NULLify
 			// Doing otherwise results in bug http://forum.mc-server.org/showthread.php?tid=355
 			delete m_Chunks[i];
-			m_Chunks[i] = NULL;
+			m_Chunks[i] = nullptr;
 		}
 	}  // for i - m_Chunks[]
 }
@@ -3033,7 +3033,7 @@ void cChunkMap::AddChunkStay(cChunkStay & a_ChunkStay)
 	for (cChunkCoordsVector::const_iterator itr = WantedChunks.begin(); itr != WantedChunks.end(); ++itr)
 	{
 		cChunkPtr Chunk = GetChunk(itr->m_ChunkX, itr->m_ChunkZ);
-		if (Chunk == NULL)
+		if (Chunk == nullptr)
 		{
 			continue;
 		}
@@ -3082,7 +3082,7 @@ void cChunkMap::DelChunkStay(cChunkStay & a_ChunkStay)
 	for (cChunkCoordsVector::const_iterator itr = Chunks.begin(), end = Chunks.end(); itr != end; ++itr)
 	{
 		cChunkPtr Chunk = GetChunkNoLoad(itr->m_ChunkX, itr->m_ChunkZ);
-		if (Chunk == NULL)
+		if (Chunk == nullptr)
 		{
 			continue;
 		}
diff --git a/src/ChunkMap.h b/src/ChunkMap.h
index 38e7f4052..51be5cb3d 100644
--- a/src/ChunkMap.h
+++ b/src/ChunkMap.h
@@ -70,29 +70,29 @@ public:
 	// Broadcast respective packets to all clients of the chunk where the event is taking place
 	// (Please keep these alpha-sorted)
 	void BroadcastAttachEntity(const cEntity & a_Entity, const cEntity * a_Vehicle);
-	void BroadcastBlockAction(int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType, const cClientHandle * a_Exclude = NULL);
-	void BroadcastBlockBreakAnimation(int a_entityID, int a_blockX, int a_blockY, int a_blockZ, char a_stage, const cClientHandle * a_Exclude = NULL);
+	void BroadcastBlockAction(int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastBlockBreakAnimation(int a_entityID, int a_blockX, int a_blockY, int a_blockZ, char a_stage, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude);
-	void BroadcastChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = NULL);
-	void BroadcastCollectEntity(const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastCollectPickup(const cPickup & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastDestroyEntity(const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEffect(const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEquipment(const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityHeadLook(const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityLook(const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityMetadata(const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMove(const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMoveLook(const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityStatus(const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityVelocity(const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL);
-	void BroadcastParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude = NULL);
-	void BroadcastRemoveEntityEffect (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
-	void BroadcastSoundEffect(const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);
-	void BroadcastSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL);
-	void BroadcastSpawnEntity(cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastThunderbolt(int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastCollectEntity(const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastCollectPickup(const cPickup & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastDestroyEntity(const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityEffect(const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityEquipment(const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityHeadLook(const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityLook(const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityMetadata(const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityRelMove(const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityRelMoveLook(const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityStatus(const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityVelocity(const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude = nullptr);
+	void BroadcastRemoveEntityEffect (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastSoundEffect(const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastSpawnEntity(cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastThunderbolt(int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastUseBed(const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ);
 	
 	/** Sends the block entity, if it is at the coords specified, to a_Client */
@@ -368,7 +368,7 @@ private:
 		/** Always returns an assigned chunkptr, but the chunk needn't be valid (loaded / generated) - callers must check */
 		cChunkPtr GetChunk( int a_ChunkX, int a_ChunkZ);
 		
-		/** Returns the specified chunk, or NULL if not created yet */
+		/** Returns the specified chunk, or nullptr if not created yet */
 		cChunk * FindChunk(int a_ChunkX, int a_ChunkZ);
 		
 		int GetX(void) const {return m_LayerX; }
@@ -431,10 +431,10 @@ private:
 	
 	typedef std::list<cChunkStay *> cChunkStays;
 
-	/** Finds the cChunkLayer object responsible for the specified chunk; returns NULL if not found. Assumes m_CSLayers is locked. */
+	/** Finds the cChunkLayer object responsible for the specified chunk; returns nullptr if not found. Assumes m_CSLayers is locked. */
 	cChunkLayer * FindLayerForChunk(int a_ChunkX, int a_ChunkZ);
 	
-	/** Returns the specified cChunkLayer object; returns NULL if not found. Assumes m_CSLayers is locked. */
+	/** Returns the specified cChunkLayer object; returns nullptr if not found. Assumes m_CSLayers is locked. */
 	cChunkLayer * FindLayer(int a_LayerX, int a_LayerZ);
 	
 	/** Returns the cChunkLayer object responsible for the specified chunk; creates it if not found. */
diff --git a/src/ChunkSender.cpp b/src/ChunkSender.cpp
index a3151eb3f..c94004780 100644
--- a/src/ChunkSender.cpp
+++ b/src/ChunkSender.cpp
@@ -35,9 +35,9 @@ void cNotifyChunkSender::Call(int a_ChunkX, int a_ChunkZ)
 
 cChunkSender::cChunkSender(void) :
 	super("ChunkSender"),
-	m_World(NULL),
+	m_World(nullptr),
 	m_RemoveCount(0),
-	m_Notify(NULL)
+	m_Notify(nullptr)
 {
 	m_Notify.SetChunkSender(this);
 }
@@ -93,7 +93,7 @@ void cChunkSender::ChunkReady(int a_ChunkX, int a_ChunkZ)
 
 void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client)
 {
-	ASSERT(a_Client != NULL);
+	ASSERT(a_Client != nullptr);
 	{
 		cCSLock Lock(m_CS);
 		if (std::find(m_SendChunks.begin(), m_SendChunks.end(), sSendChunk(a_ChunkX, a_ChunkZ, a_Client)) != m_SendChunks.end())
@@ -161,7 +161,7 @@ void cChunkSender::Execute(void)
 			m_ChunksReady.pop_front();
 			Lock.Unlock();
 			
-			SendChunk(Coords.m_ChunkX, Coords.m_ChunkZ, NULL);
+			SendChunk(Coords.m_ChunkX, Coords.m_ChunkZ, nullptr);
 		}
 		else
 		{
@@ -189,10 +189,10 @@ void cChunkSender::Execute(void)
 
 void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client)
 {
-	ASSERT(m_World != NULL);
+	ASSERT(m_World != nullptr);
 	
 	// Ask the client if it still wants the chunk:
-	if (a_Client != NULL)
+	if (a_Client != nullptr)
 	{
 		if (!a_Client->WantsSendChunk(a_ChunkX, a_ChunkZ))
 		{
@@ -227,7 +227,7 @@ void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Clien
 	cChunkDataSerializer Data(m_BlockTypes, m_BlockMetas, m_BlockLight, m_BlockSkyLight, m_BiomeMap);
 	
 	// Send:
-	if (a_Client == NULL)
+	if (a_Client == nullptr)
 	{
 		m_World->BroadcastChunkData(a_ChunkX, a_ChunkZ, Data);
 	}
@@ -239,7 +239,7 @@ void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Clien
 	// Send block-entity packets:
 	for (sBlockCoords::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
 	{
-		if (a_Client == NULL)
+		if (a_Client == nullptr)
 		{
 			m_World->BroadcastBlockEntity(itr->m_BlockX, itr->m_BlockY, itr->m_BlockZ);
 		}
diff --git a/src/ChunkSender.h b/src/ChunkSender.h
index a0e9087a9..f17029aea 100644
--- a/src/ChunkSender.h
+++ b/src/ChunkSender.h
@@ -158,7 +158,7 @@ protected:
 	virtual void Entity       (cEntity *      a_Entity) override;
 	virtual void BlockEntity  (cBlockEntity * a_Entity) override;
 
-	/// Sends the specified chunk to a_Client, or to all chunk clients if a_Client == NULL
+	/// Sends the specified chunk to a_Client, or to all chunk clients if a_Client == nullptr
 	void SendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client);
 } ;
 
diff --git a/src/ChunkStay.cpp b/src/ChunkStay.cpp
index 38aa89a37..0772787de 100644
--- a/src/ChunkStay.cpp
+++ b/src/ChunkStay.cpp
@@ -12,7 +12,7 @@
 
 
 cChunkStay::cChunkStay(void) :
-	m_ChunkMap(NULL)
+	m_ChunkMap(nullptr)
 {
 }
 
@@ -31,7 +31,7 @@ cChunkStay::~cChunkStay()
 
 void cChunkStay::Clear(void)
 {
-	ASSERT(m_ChunkMap == NULL);
+	ASSERT(m_ChunkMap == nullptr);
 	m_Chunks.clear();
 }
 
@@ -41,7 +41,7 @@ void cChunkStay::Clear(void)
 
 void cChunkStay::Add(int a_ChunkX, int a_ChunkZ)
 {
-	ASSERT(m_ChunkMap == NULL);
+	ASSERT(m_ChunkMap == nullptr);
 
 	for (cChunkCoordsVector::const_iterator itr = m_Chunks.begin(); itr != m_Chunks.end(); ++itr)
 	{
@@ -60,7 +60,7 @@ void cChunkStay::Add(int a_ChunkX, int a_ChunkZ)
 
 void cChunkStay::Remove(int a_ChunkX, int a_ChunkZ)
 {
-	ASSERT(m_ChunkMap == NULL);
+	ASSERT(m_ChunkMap == nullptr);
 
 	for (cChunkCoordsVector::iterator itr = m_Chunks.begin(); itr != m_Chunks.end(); ++itr)
 	{
@@ -79,7 +79,7 @@ void cChunkStay::Remove(int a_ChunkX, int a_ChunkZ)
 
 void cChunkStay::Enable(cChunkMap & a_ChunkMap)
 {
-	ASSERT(m_ChunkMap == NULL);
+	ASSERT(m_ChunkMap == nullptr);
 	
 	m_OutstandingChunks = m_Chunks;
 	m_ChunkMap = &a_ChunkMap;
@@ -92,10 +92,10 @@ void cChunkStay::Enable(cChunkMap & a_ChunkMap)
 
 void cChunkStay::Disable(void)
 {
-	ASSERT(m_ChunkMap != NULL);
+	ASSERT(m_ChunkMap != nullptr);
 	
 	cChunkMap * ChunkMap = m_ChunkMap;
-	m_ChunkMap = NULL;
+	m_ChunkMap = nullptr;
 	ChunkMap->DelChunkStay(*this);
 }
 
diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp
index 3dcbaa6a9..202a8d02f 100644
--- a/src/ClientHandle.cpp
+++ b/src/ClientHandle.cpp
@@ -55,7 +55,7 @@ cClientHandle::cClientHandle(const cSocket * a_Socket, int a_ViewDistance) :
 	m_ViewDistance(a_ViewDistance),
 	m_IPString(a_Socket->GetIPString()),
 	m_OutgoingData(64 KiB),
-	m_Player(NULL),
+	m_Player(nullptr),
 	m_HasSentDC(false),
 	m_LastStreamedChunkX(0x7fffffff),  // bogus chunk coords to force streaming upon login
 	m_LastStreamedChunkZ(0x7fffffff),
@@ -105,10 +105,10 @@ cClientHandle::~cClientHandle()
 		m_ChunksToSend.clear();
 	}
 
-	if (m_Player != NULL)
+	if (m_Player != nullptr)
 	{
 		cWorld * World = m_Player->GetWorld();
-		if (World != NULL)
+		if (World != nullptr)
 		{
 			if (!m_Username.empty())
 			{
@@ -120,7 +120,7 @@ cClientHandle::~cClientHandle()
 			m_Player->Destroy();
 		}
 		delete m_Player;
-		m_Player = NULL;
+		m_Player = nullptr;
 	}
 
 	if (!m_HasSentDC)
@@ -132,7 +132,7 @@ cClientHandle::~cClientHandle()
 	cRoot::Get()->GetServer()->RemoveClient(this);
 	
 	delete m_Protocol;
-	m_Protocol = NULL;
+	m_Protocol = nullptr;
 	
 	LOGD("ClientHandle at %p deleted", this);
 }
@@ -156,7 +156,7 @@ void cClientHandle::Destroy(void)
 	// DEBUG:
 	LOGD("%s: client %p, \"%s\"", __FUNCTION__, this, m_Username.c_str());
 	
-	if ((m_Player != NULL) && (m_Player->GetWorld() != NULL))
+	if ((m_Player != nullptr) && (m_Player->GetWorld() != nullptr))
 	{
 		RemoveFromAllChunks();
 		m_Player->GetWorld()->RemoveClientFromChunkSender(this);
@@ -297,7 +297,7 @@ void cClientHandle::Authenticate(const AString & a_Name, const AString & a_UUID,
 		return;
 	}
 	
-	ASSERT(m_Player == NULL);
+	ASSERT(m_Player == nullptr);
 
 	m_Username = a_Name;
 	
@@ -318,7 +318,7 @@ void cClientHandle::Authenticate(const AString & a_Name, const AString & a_UUID,
 	m_Player = new cPlayer(this, GetUsername());
 
 	cWorld * World = cRoot::Get()->GetWorld(m_Player->GetLoadedWorldName());
-	if (World == NULL)
+	if (World == nullptr)
 	{
 		World = cRoot::Get()->GetDefaultWorld();
 	}
@@ -394,7 +394,7 @@ void cClientHandle::StreamChunks(void)
 		return;
 	}
 
-	ASSERT(m_Player != NULL);
+	ASSERT(m_Player != nullptr);
 
 	int ChunkPosX = FAST_FLOOR_DIV((int)m_Player->GetPosX(), cChunkDef::Width);
 	int ChunkPosZ = FAST_FLOOR_DIV((int)m_Player->GetPosZ(), cChunkDef::Width);
@@ -409,7 +409,7 @@ void cClientHandle::StreamChunks(void)
 	LOGD("Streaming chunks centered on [%d, %d], view distance %d", ChunkPosX, ChunkPosZ, m_ViewDistance);
 	
 	cWorld * World = m_Player->GetWorld();
-	ASSERT(World != NULL);
+	ASSERT(World != nullptr);
 
 	// Remove all loaded chunks that are no longer in range; deferred to out-of-CS:
 	cChunkCoordsList RemoveChunks;
@@ -495,7 +495,7 @@ void cClientHandle::StreamChunk(int a_ChunkX, int a_ChunkZ)
 	}
 	
 	cWorld * World = m_Player->GetWorld();
-	ASSERT(World != NULL);
+	ASSERT(World != nullptr);
 
 	if (World->AddChunkClient(a_ChunkX, a_ChunkZ, this))
 	{
@@ -516,7 +516,7 @@ void cClientHandle::StreamChunk(int a_ChunkX, int a_ChunkZ)
 void cClientHandle::RemoveFromAllChunks()
 {
 	cWorld * World = m_Player->GetWorld();
-	if (World != NULL)
+	if (World != nullptr)
 	{
 		World->RemoveClientFromChunks(this);
 	}
@@ -632,7 +632,7 @@ void cClientHandle::HandlePlayerAbilities(bool a_CanFly, bool a_IsFlying, float
 
 void cClientHandle::HandlePlayerPos(double a_PosX, double a_PosY, double a_PosZ, double a_Stance, bool a_IsOnGround)
 {
-	if ((m_Player == NULL) || (m_State != csPlaying))
+	if ((m_Player == nullptr) || (m_State != csPlaying))
 	{
 		// The client hasn't been spawned yet and sends nonsense, we know better
 		return;
@@ -766,7 +766,7 @@ void cClientHandle::UnregisterPluginChannels(const AStringVector & a_ChannelList
 void cClientHandle::HandleBeaconSelection(int a_PrimaryEffect, int a_SecondaryEffect)
 {
 	cWindow * Window = m_Player->GetWindow();
-	if ((Window == NULL) || (Window->GetWindowType() != cWindow::wtBeacon))
+	if ((Window == nullptr) || (Window->GetWindowType() != cWindow::wtBeacon))
 	{
 		return;
 	}
@@ -842,7 +842,7 @@ void cClientHandle::HandleCommandBlockEntityChange(int a_EntityID, const AString
 
 void cClientHandle::HandleAnvilItemName(const AString & a_ItemName)
 {
-	if ((m_Player->GetWindow() == NULL) || (m_Player->GetWindow()->GetWindowType() != cWindow::wtAnvil))
+	if ((m_Player->GetWindow() == nullptr) || (m_Player->GetWindow()->GetWindowType() != cWindow::wtAnvil))
 	{
 		return;
 	}
@@ -1479,7 +1479,7 @@ void cClientHandle::HandleChat(const AString & a_Message)
 
 void cClientHandle::HandlePlayerLook(float a_Rotation, float a_Pitch, bool a_IsOnGround)
 {
-	if ((m_Player == NULL) || (m_State != csPlaying))
+	if ((m_Player == nullptr) || (m_State != csPlaying))
 	{
 		return;
 	}
@@ -1579,7 +1579,7 @@ void cClientHandle::HandleWindowClick(char a_WindowID, short a_SlotNum, eClickAc
 	);
 	
 	cWindow * Window = m_Player->GetWindow();
-	if (Window == NULL)
+	if (Window == nullptr)
 	{
 		LOGWARNING("Player \"%s\" clicked in a non-existent window. Ignoring", m_Username.c_str());
 		return;
@@ -1671,7 +1671,7 @@ void cClientHandle::HandleUseEntity(int a_TargetEntityID, bool a_IsLeftClick)
 
 void cClientHandle::HandleRespawn(void)
 {
-	if (m_Player == NULL)
+	if (m_Player == nullptr)
 	{
 		Destroy();
 		return;
@@ -1760,7 +1760,7 @@ void cClientHandle::HandleEntitySprinting(int a_EntityID, bool a_IsSprinting)
 
 void cClientHandle::HandleUnmount(void)
 {
-	if (m_Player == NULL)
+	if (m_Player == nullptr)
 	{
 		return;
 	}
@@ -1865,8 +1865,8 @@ void cClientHandle::RemoveFromWorld(void)
 
 bool cClientHandle::CheckBlockInteractionsRate(void)
 {
-	ASSERT(m_Player != NULL);
-	ASSERT(m_Player->GetWorld() != NULL);
+	ASSERT(m_Player != nullptr);
+	ASSERT(m_Player->GetWorld() != nullptr);
 
 	if (m_NumBlockChangeInteractionsThisTick > MAX_BLOCK_CHANGE_INTERACTIONS)
 	{
@@ -1897,7 +1897,7 @@ void cClientHandle::Tick(float a_Dt)
 		Destroy();
 	}
 	
-	if (m_Player == NULL)
+	if (m_Player == nullptr)
 	{
 		return;
 	}
@@ -2047,10 +2047,10 @@ void cClientHandle::SendBlockChanges(int a_ChunkX, int a_ChunkZ, const sSetBlock
 void cClientHandle::SendChat(const AString & a_Message, eMessageType a_ChatPrefix, const AString & a_AdditionalData)
 {
 	cWorld * World = GetPlayer()->GetWorld();
-	if (World == NULL)
+	if (World == nullptr)
 	{
 		World = cRoot::Get()->GetWorld(GetPlayer()->GetLoadedWorldName());
-		if (World == NULL)
+		if (World == nullptr)
 		{
 			World = cRoot::Get()->GetDefaultWorld();
 		}
@@ -2075,7 +2075,7 @@ void cClientHandle::SendChat(const cCompositeChat & a_Message)
 
 void cClientHandle::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer)
 {
-	ASSERT(m_Player != NULL);
+	ASSERT(m_Player != nullptr);
 	
 	// Check chunks being sent, erase them from m_ChunksToSend:
 	bool Found = false;
@@ -2906,7 +2906,7 @@ void cClientHandle::HandleEnchantItem(Byte & a_WindowID, Byte & a_Enchantment)
 	}
 
 	if (
-		(m_Player->GetWindow() == NULL) ||
+		(m_Player->GetWindow() == nullptr) ||
 		(m_Player->GetWindow()->GetWindowID() != a_WindowID) ||
 		(m_Player->GetWindow()->GetWindowType() != cWindow::wtEnchantment)
 	)
diff --git a/src/CraftingRecipes.cpp b/src/CraftingRecipes.cpp
index 0828a6c74..64fb21181 100644
--- a/src/CraftingRecipes.cpp
+++ b/src/CraftingRecipes.cpp
@@ -59,7 +59,7 @@ cCraftingGrid::cCraftingGrid(const cCraftingGrid & a_Original) :
 cCraftingGrid::~cCraftingGrid()
 {
 	delete[] m_Items;
-	m_Items = NULL;
+	m_Items = nullptr;
 }
 
 
@@ -291,7 +291,7 @@ void cCraftingRecipes::GetRecipe(cPlayer & a_Player, cCraftingGrid & a_CraftingG
 	// Built-in recipes:
 	std::auto_ptr<cRecipe> Recipe(FindRecipe(a_CraftingGrid.GetItems(), a_CraftingGrid.GetWidth(), a_CraftingGrid.GetHeight()));
 	a_Recipe.Clear();
-	if (Recipe.get() == NULL)
+	if (Recipe.get() == nullptr)
 	{
 		// Allow plugins to intercept a no-recipe-found situation:
 		cRoot::Get()->GetPluginManager()->CallHookCraftingNoRecipe(a_Player, a_CraftingGrid, &a_Recipe);
@@ -603,9 +603,9 @@ cCraftingRecipes::cRecipe * cCraftingRecipes::FindRecipe(const cItem * a_Craftin
 	// Search in the possibly minimized grid, but keep the stride:
 	const cItem * Grid = a_CraftingGrid + GridLeft + (a_GridWidth * GridTop);
 	cRecipe * Recipe = FindRecipeCropped(Grid, GridWidth, GridHeight, a_GridWidth);
-	if (Recipe == NULL)
+	if (Recipe == nullptr)
 	{
-		return NULL;
+		return nullptr;
 	}
 	
 	// A recipe has been found, move it to correspond to the original crafting grid:
@@ -637,7 +637,7 @@ cCraftingRecipes::cRecipe * cCraftingRecipes::FindRecipeCropped(const cItem * a_
 		for (int x = 0; x <= MaxOfsX; x++) for (int y = 0; y <= MaxOfsY; y++)
 		{
 			cRecipe * Recipe = MatchRecipe(a_CraftingGrid, a_GridWidth, a_GridHeight, a_GridStride, *itr, x, y);
-			if (Recipe != NULL)
+			if (Recipe != nullptr)
 			{
 				return Recipe;
 			}
@@ -645,7 +645,7 @@ cCraftingRecipes::cRecipe * cCraftingRecipes::FindRecipeCropped(const cItem * a_
 	}  // for itr - m_Recipes[]
 	
 	// No matching recipe found
-	return NULL;
+	return nullptr;
 }
 
 
@@ -681,7 +681,7 @@ cCraftingRecipes::cRecipe * cCraftingRecipes::MatchRecipe(const cItem * a_Crafti
 		)
 		{
 			// Doesn't match
-			return NULL;
+			return nullptr;
 		}
 		HasMatched[itrS->x + a_OffsetX][itrS->y + a_OffsetY] = true;
 	}  // for itrS - Recipe->m_Ingredients[]
@@ -743,7 +743,7 @@ cCraftingRecipes::cRecipe * cCraftingRecipes::MatchRecipe(const cItem * a_Crafti
 		}  // for x
 		if (!Found)
 		{
-			return NULL;
+			return nullptr;
 		}
 	}  // for itrS - a_Recipe->m_Ingredients[]
 	
@@ -753,7 +753,7 @@ cCraftingRecipes::cRecipe * cCraftingRecipes::MatchRecipe(const cItem * a_Crafti
 		if (!HasMatched[x][y] && !a_CraftingGrid[x + a_GridStride * y].IsEmpty())
 		{
 			// There's an unmatched item in the grid
-			return NULL;
+			return nullptr;
 		}
 	}  // for y, for x
 	
diff --git a/src/CraftingRecipes.h b/src/CraftingRecipes.h
index 5ebabe098..44444d42e 100644
--- a/src/CraftingRecipes.h
+++ b/src/CraftingRecipes.h
@@ -157,13 +157,13 @@ protected:
 	/// Moves the recipe to top-left corner, sets its MinWidth / MinHeight
 	void NormalizeIngredients(cRecipe * a_Recipe);
 	
-	/// Finds a recipe matching the crafting grid. Returns a newly allocated recipe (with all its coords set) or NULL if not found. Caller must delete return value!
+	/// Finds a recipe matching the crafting grid. Returns a newly allocated recipe (with all its coords set) or nullptr if not found. Caller must delete return value!
 	cRecipe * FindRecipe(const cItem * a_CraftingGrid, int a_GridWidth, int a_GridHeight);
 	
 	/// Same as FindRecipe, but the grid is guaranteed to be of minimal dimensions needed
 	cRecipe * FindRecipeCropped(const cItem * a_CraftingGrid, int a_GridWidth, int a_GridHeight, int a_GridStride);
 	
-	/// Checks if the grid matches the specified recipe, offset by the specified offsets. Returns a matched cRecipe * if so, or NULL if not matching. Caller must delete the return value!
+	/// Checks if the grid matches the specified recipe, offset by the specified offsets. Returns a matched cRecipe * if so, or nullptr if not matching. Caller must delete the return value!
 	cRecipe * MatchRecipe(const cItem * a_CraftingGrid, int a_GridWidth, int a_GridHeight, int a_GridStride, const cRecipe * a_Recipe, int a_OffsetX, int a_OffsetY);
 
 	/** Searches for anything firework related, and does the data setting if appropriate */
diff --git a/src/Defines.h b/src/Defines.h
index 6355b75b4..d32b7f9c3 100644
--- a/src/Defines.h
+++ b/src/Defines.h
@@ -477,16 +477,16 @@ inline void AddFaceDirection(int & a_BlockX, unsigned char & a_BlockY, int & a_B
 
 
 
-#define PI 3.14159265358979323846264338327950288419716939937510582097494459072381640628620899862803482534211706798f
+
 
 inline void EulerToVector(double a_Pan, double a_Pitch, double & a_X, double & a_Y, double & a_Z)
 {
 	// 	a_X = sinf ( a_Pan / 180 * PI) * cosf ( a_Pitch / 180 * PI);
 	// 	a_Y = -sinf ( a_Pitch / 180 * PI);
 	// 	a_Z = -cosf ( a_Pan / 180 * PI) * cosf ( a_Pitch / 180 * PI);
-	a_X = cos(a_Pan / 180 * PI) * cos(a_Pitch / 180 * PI);
-	a_Y = sin(a_Pan / 180 * PI) * cos(a_Pitch / 180 * PI);
-	a_Z = sin(a_Pitch / 180 * PI);
+	a_X = cos(a_Pan / 180 * M_PI) * cos(a_Pitch / 180 * M_PI);
+	a_Y = sin(a_Pan / 180 * M_PI) * cos(a_Pitch / 180 * M_PI);
+	a_Z = sin(a_Pitch / 180 * M_PI);
 }
 
 
@@ -502,10 +502,10 @@ inline void VectorToEuler(double a_X, double a_Y, double a_Z, double & a_Pan, do
 	}
 	else
 	{
-		a_Pan = atan2(a_Z, a_X) * 180 / PI - 90;
+		a_Pan = atan2(a_Z, a_X) * 180 / M_PI - 90;
 	}
 
-	a_Pitch = atan2(a_Y, r) * 180 / PI;
+	a_Pitch = atan2(a_Y, r) * 180 / M_PI;
 }
 
 
diff --git a/src/Entities/ArrowEntity.cpp b/src/Entities/ArrowEntity.cpp
index 7e429c62e..30f18f677 100644
--- a/src/Entities/ArrowEntity.cpp
+++ b/src/Entities/ArrowEntity.cpp
@@ -217,7 +217,7 @@ void cArrowEntity::Tick(float a_Dt, cChunk & a_Chunk)
 		int RelPosZ = m_HitBlockPos.z - a_Chunk.GetPosZ() * cChunkDef::Width;
 		cChunk * Chunk = a_Chunk.GetRelNeighborChunkAdjustCoords(RelPosX, RelPosZ);
 		
-		if (Chunk == NULL)
+		if (Chunk == nullptr)
 		{
 			// Inside an unloaded chunk, abort
 			return;
diff --git a/src/Entities/Boat.cpp b/src/Entities/Boat.cpp
index 328a70846..953213bca 100644
--- a/src/Entities/Boat.cpp
+++ b/src/Entities/Boat.cpp
@@ -42,7 +42,7 @@ bool cBoat::DoTakeDamage(TakeDamageInfo & TDI)
 
 	if (GetHealth() == 0)
 	{
-		if (TDI.Attacker != NULL)
+		if (TDI.Attacker != nullptr)
 		{
 			if (TDI.Attacker->IsPlayer())
 			{
@@ -64,7 +64,7 @@ void cBoat::OnRightClicked(cPlayer & a_Player)
 {
 	super::OnRightClicked(a_Player);
 
-	if (m_Attachee != NULL)
+	if (m_Attachee != nullptr)
 	{
 		if (m_Attachee->GetUniqueID() == a_Player.GetUniqueID())
 		{
diff --git a/src/Entities/Entity.cpp b/src/Entities/Entity.cpp
index da85dec50..afc61c73f 100644
--- a/src/Entities/Entity.cpp
+++ b/src/Entities/Entity.cpp
@@ -29,8 +29,8 @@ cEntity::cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z, d
 	: m_UniqueID(0)
 	, m_Health(1)
 	, m_MaxHealth(1)
-	, m_AttachedTo(NULL)
-	, m_Attachee(NULL)
+	, m_AttachedTo(nullptr)
+	, m_Attachee(nullptr)
 	, m_bDirtyHead(true)
 	, m_bDirtyOrientation(true)
 	, m_bHasSentNoSpeed(true)
@@ -38,9 +38,9 @@ cEntity::cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z, d
 	, m_Gravity(-9.81f)
 	, m_LastPos(a_X, a_Y, a_Z)
 	, m_IsInitialized(false)
-	, m_WorldTravellingFrom(NULL)
+	, m_WorldTravellingFrom(nullptr)
 	, m_EntityType(a_EntityType)
-	, m_World(NULL)
+	, m_World(nullptr)
 	, m_IsFireproof(false)
 	, m_TicksSinceLastBurnDamage(0)
 	, m_TicksSinceLastLavaDamage(0)
@@ -73,7 +73,7 @@ cEntity::cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z, d
 cEntity::~cEntity()
 {
 	// Before deleting, the entity needs to have been removed from the world, if ever added
-	ASSERT((m_World == NULL) || !m_World->HasEntity(m_UniqueID));
+	ASSERT((m_World == nullptr) || !m_World->HasEntity(m_UniqueID));
 	
 	/*
 	// DEBUG:
@@ -85,11 +85,11 @@ cEntity::~cEntity()
 		);
 	*/
 	
-	if (m_AttachedTo != NULL)
+	if (m_AttachedTo != nullptr)
 	{
 		Detach();
 	}
-	if (m_Attachee != NULL)
+	if (m_Attachee != nullptr)
 	{
 		m_Attachee->Detach();
 	}
@@ -242,7 +242,7 @@ void cEntity::TakeDamage(eDamageType a_DamageType, cEntity * a_Attacker, int a_R
 	TDI.FinalDamage = a_FinalDamage;
 	
 	Vector3d Heading(0, 0, 0);
-	if (a_Attacker != NULL)
+	if (a_Attacker != nullptr)
 	{
 		Heading = a_Attacker->GetLookVector() * (a_Attacker->IsSprinting() ? 16 : 11);
 		Heading.y = 1.6;
@@ -265,7 +265,7 @@ void cEntity::SetYawFromSpeed(void)
 		SetYaw(0);
 		return;
 	}
-	SetYaw(atan2(m_Speed.x, m_Speed.z) * 180 / PI);
+	SetYaw(atan2(m_Speed.x, m_Speed.z) * 180 / M_PI);
 }
 
 
@@ -282,7 +282,7 @@ void cEntity::SetPitchFromSpeed(void)
 		SetPitch(0);
 		return;
 	}
-	SetPitch(atan2(m_Speed.y, xz) * 180 / PI);
+	SetPitch(atan2(m_Speed.y, xz) * 180 / M_PI);
 }
 
 
@@ -308,7 +308,7 @@ bool cEntity::DoTakeDamage(TakeDamageInfo & a_TDI)
 		return false;
 	}
 
-	if ((a_TDI.Attacker != NULL) && (a_TDI.Attacker->IsPlayer()))
+	if ((a_TDI.Attacker != nullptr) && (a_TDI.Attacker->IsPlayer()))
 	{
 		cPlayer * Player = (cPlayer *)a_TDI.Attacker;
 
@@ -544,7 +544,7 @@ bool cEntity::DoTakeDamage(TakeDamageInfo & a_TDI)
 	m_Health = std::max(m_Health, 0);
 
 	// Add knockback:
-	if ((IsMob() || IsPlayer()) && (a_TDI.Attacker != NULL))
+	if ((IsMob() || IsPlayer()) && (a_TDI.Attacker != nullptr))
 	{
 		int KnockbackLevel = a_TDI.Attacker->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchKnockback);  // More common enchantment
 		if (KnockbackLevel < 1)
@@ -571,7 +571,7 @@ bool cEntity::DoTakeDamage(TakeDamageInfo & a_TDI)
 	{
 		KilledBy(a_TDI);
 
-		if (a_TDI.Attacker != NULL)
+		if (a_TDI.Attacker != nullptr)
 		{
 			a_TDI.Attacker->Killed(this);
 		}
@@ -778,7 +778,7 @@ void cEntity::Tick(float a_Dt, cChunk & a_Chunk)
 		m_InvulnerableTicks--;
 	}
 
-	if (m_AttachedTo != NULL)
+	if (m_AttachedTo != nullptr)
 	{
 		Vector3d DeltaPos = m_Pos - m_AttachedTo->GetPosition();
 		if (DeltaPos.Length() > 0.5)
@@ -1092,7 +1092,7 @@ void cEntity::TickBurning(cChunk & a_Chunk)
 		{
 			if (!m_IsFireproof)
 			{
-				TakeDamage(dtOnFire, NULL, BURN_DAMAGE, 0);
+				TakeDamage(dtOnFire, nullptr, BURN_DAMAGE, 0);
 			}
 			m_TicksSinceLastBurnDamage = 0;
 		}
@@ -1163,7 +1163,7 @@ void cEntity::TickBurning(cChunk & a_Chunk)
 		{
 			if (!m_IsFireproof)
 			{
-				TakeDamage(dtLavaContact, NULL, LAVA_DAMAGE, 0);
+				TakeDamage(dtLavaContact, nullptr, LAVA_DAMAGE, 0);
 			}
 			m_TicksSinceLastLavaDamage = 0;
 		}
@@ -1184,7 +1184,7 @@ void cEntity::TickBurning(cChunk & a_Chunk)
 		{
 			if (!m_IsFireproof)
 			{
-				TakeDamage(dtFireContact, NULL, FIRE_DAMAGE, 0);
+				TakeDamage(dtFireContact, nullptr, FIRE_DAMAGE, 0);
 			}
 			m_TicksSinceLastFireDamage = 0;
 		}
@@ -1213,7 +1213,7 @@ void cEntity::TickInVoid(cChunk & a_Chunk)
 {
 	if (m_TicksSinceLastVoidDamage == 20)
 	{
-		TakeDamage(dtInVoid, NULL, 2, 0);
+		TakeDamage(dtInVoid, nullptr, 2, 0);
 		m_TicksSinceLastVoidDamage = 0;
 	}
 	else
@@ -1239,7 +1239,7 @@ void cEntity::DetectCacti(void)
 		(((GetPosY() - Y < 1) && (GetWorld()->GetBlock(X, Y, Z) == E_BLOCK_CACTUS))))
 		)
 	{
-		TakeDamage(dtCactusContact, NULL, 1, 0);
+		TakeDamage(dtCactusContact, nullptr, 1, 0);
 	}
 }
 
@@ -1380,7 +1380,7 @@ bool cEntity::DetectPortal()
 bool cEntity::DoMoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn)
 {
 	UNUSED(a_ShouldSendRespawn);
-	ASSERT(a_World != NULL);
+	ASSERT(a_World != nullptr);
 
 	if (GetWorld() == a_World)
 	{
@@ -1406,7 +1406,7 @@ bool cEntity::DoMoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn)
 bool cEntity::MoveToWorld(const AString & a_WorldName, bool a_ShouldSendRespawn)
 {
 	cWorld * World = cRoot::Get()->GetWorld(a_WorldName);
-	if (World == NULL)
+	if (World == nullptr)
 	{
 		LOG("%s: Couldn't find world \"%s\".", __FUNCTION__, a_WorldName.c_str());
 		return false;
@@ -1493,7 +1493,7 @@ void cEntity::HandleAir(void)
 			if (m_AirTickTimer <= 0)
 			{
 				// Damage player
-				TakeDamage(dtDrowning, NULL, 1, 1, 0);
+				TakeDamage(dtDrowning, nullptr, 1, 1, 0);
 				// Reset timer
 				m_AirTickTimer = DROWNING_TICKS;
 			}
@@ -1708,7 +1708,7 @@ void cEntity::AttachTo(cEntity * a_AttachTo)
 		// Already attached to that entity, nothing to do here
 		return;
 	}
-	if (m_AttachedTo != NULL)
+	if (m_AttachedTo != nullptr)
 	{
 		// Detach from any previous entity:
 		Detach();
@@ -1726,14 +1726,14 @@ void cEntity::AttachTo(cEntity * a_AttachTo)
 
 void cEntity::Detach(void)
 {
-	if (m_AttachedTo == NULL)
+	if (m_AttachedTo == nullptr)
 	{
 		// Attached to no entity, our work is done
 		return;
 	}
-	m_AttachedTo->m_Attachee = NULL;
-	m_AttachedTo = NULL;
-	m_World->BroadcastAttachEntity(*this, NULL);
+	m_AttachedTo->m_Attachee = nullptr;
+	m_AttachedTo = nullptr;
+	m_World->BroadcastAttachEntity(*this, nullptr);
 }
 
 
@@ -1956,7 +1956,7 @@ void cEntity::HandleSpeedFromAttachee(float a_Forward, float a_Sideways)
 
 void cEntity::SteerVehicle(float a_Forward, float a_Sideways)
 {
-	if (m_AttachedTo == NULL)
+	if (m_AttachedTo == nullptr)
 	{
 		return;
 	}
diff --git a/src/Entities/Entity.h b/src/Entities/Entity.h
index 07754791d..af545fe4a 100644
--- a/src/Entities/Entity.h
+++ b/src/Entities/Entity.h
@@ -32,7 +32,7 @@
 #define POSZ_TOINT FloorC(GetPosZ())
 #define POS_TOINT  Vector3i(POSXTOINT, POSYTOINT, POSZTOINT)
 
-#define GET_AND_VERIFY_CURRENT_CHUNK(ChunkVarName, X, Z) cChunk * ChunkVarName = a_Chunk.GetNeighborChunk(X, Z); if ((ChunkVarName == NULL) || !ChunkVarName->IsValid()) { return; }
+#define GET_AND_VERIFY_CURRENT_CHUNK(ChunkVarName, X, Z) cChunk * ChunkVarName = a_Chunk.GetNeighborChunk(X, Z); if ((ChunkVarName == nullptr) || !ChunkVarName->IsValid()) { return; }
 
 
 
@@ -309,7 +309,7 @@ public:
 	/// Returns the currently equipped boots; empty item if none
 	virtual cItem GetEquippedBoots(void) const { return cItem(); }
 
-	/// Called when the health drops below zero. a_Killer may be NULL (environmental damage)
+	/// Called when the health drops below zero. a_Killer may be nullptr (environmental damage)
 	virtual void KilledBy(TakeDamageInfo & a_TDI);
 
 	/// Called when the entity kills another entity
@@ -401,7 +401,7 @@ public:
 	void SetWorldTravellingFrom(cWorld * a_World) { m_WorldTravellingFrom = a_World; }
 	
 	/// Updates clients of changes in the entity.
-	virtual void BroadcastMovementUpdate(const cClientHandle * a_Exclude = NULL);
+	virtual void BroadcastMovementUpdate(const cClientHandle * a_Exclude = nullptr);
 	
 	/// Attaches to the specified entity; detaches from any previous one first
 	void AttachTo(cEntity * a_AttachTo);
@@ -450,7 +450,7 @@ public:
 	virtual void OnRightClicked(cPlayer & a_Player) {}
 
 	/// Returns the list of drops for this pawn when it is killed. May check a_Killer for special handling (sword of looting etc.). Called from KilledBy().
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL)
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr)
 	{
 		UNUSED(a_Drops);
 		UNUSED(a_Killer);
@@ -471,10 +471,10 @@ protected:
 	int m_Health;
 	int m_MaxHealth;
 	
-	/// The entity to which this entity is attached (vehicle), NULL if none
+	/// The entity to which this entity is attached (vehicle), nullptr if none
 	cEntity * m_AttachedTo;
 	
-	/// The entity which is attached to this entity (rider), NULL if none
+	/// The entity which is attached to this entity (rider), nullptr if none
 	cEntity * m_Attachee;
 
 	/** Stores whether head yaw has been set manually */
@@ -502,7 +502,7 @@ protected:
 	bool m_IsInitialized;
 
 	/** World entity is travelling from
-	Set to a valid world pointer by MoveToWorld; reset to NULL when the entity is removed from the old world
+	Set to a valid world pointer by MoveToWorld; reset to nullptr when the entity is removed from the old world
 	Can't be a simple boolean as context switches between worlds may leave the new chunk processing (and therefore immediately removing) the entity before the old chunk could remove it
 	*/
 	cWorld * m_WorldTravellingFrom;
diff --git a/src/Entities/EntityEffect.cpp b/src/Entities/EntityEffect.cpp
index b1ddaa30e..bae686b77 100644
--- a/src/Entities/EntityEffect.cpp
+++ b/src/Entities/EntityEffect.cpp
@@ -216,7 +216,7 @@ cEntityEffect * cEntityEffect::CreateEntityEffect(cEntityEffect::eType a_EffectT
 	}
 	
 	ASSERT(!"Unhandled entity effect type!");
-	return NULL;
+	return nullptr;
 }
 
 
@@ -329,7 +329,7 @@ void cEntityEffectInstantHealth::OnActivate(cPawn & a_Target)
 	
 	if (a_Target.IsMob() && ((cMonster &) a_Target).IsUndead())
 	{
-		a_Target.TakeDamage(dtPotionOfHarming, NULL, amount, 0);  // TODO: Store attacker in a pointer-safe way, pass to TakeDamage
+		a_Target.TakeDamage(dtPotionOfHarming, nullptr, amount, 0);  // TODO: Store attacker in a pointer-safe way, pass to TakeDamage
 		return;
 	}
 	a_Target.Heal(amount);
@@ -352,7 +352,7 @@ void cEntityEffectInstantDamage::OnActivate(cPawn & a_Target)
 		a_Target.Heal(amount);
 		return;
 	}
-	a_Target.TakeDamage(dtPotionOfHarming, NULL, amount, 0);  // TODO: Store attacker in a pointer-safe way, pass to TakeDamage
+	a_Target.TakeDamage(dtPotionOfHarming, nullptr, amount, 0);  // TODO: Store attacker in a pointer-safe way, pass to TakeDamage
 }
 
 
@@ -452,7 +452,7 @@ void cEntityEffectPoison::OnTick(cPawn & a_Target)
 		// Cannot take poison damage when health is at 1
 		if (a_Target.GetHealth() > 1)
 		{
-			a_Target.TakeDamage(dtPoisoning, NULL, 1, 0);
+			a_Target.TakeDamage(dtPoisoning, nullptr, 1, 0);
 		}
 	}
 }
@@ -473,7 +473,7 @@ void cEntityEffectWither::OnTick(cPawn & a_Target)
 
 	if ((m_Ticks % frequency) == 0)
 	{
-		a_Target.TakeDamage(dtWither, NULL, 1, 0);
+		a_Target.TakeDamage(dtWither, nullptr, 1, 0);
 	}
 }
 
diff --git a/src/Entities/ExpOrb.cpp b/src/Entities/ExpOrb.cpp
index 73d5cbfed..751308661 100644
--- a/src/Entities/ExpOrb.cpp
+++ b/src/Entities/ExpOrb.cpp
@@ -45,7 +45,7 @@ void cExpOrb::SpawnOn(cClientHandle & a_Client)
 void cExpOrb::Tick(float a_Dt, cChunk & a_Chunk)
 {
 	cPlayer * a_ClosestPlayer(m_World->FindClosestPlayer(Vector3f(GetPosition()), 5));
-	if (a_ClosestPlayer != NULL)
+	if (a_ClosestPlayer != nullptr)
 	{
 		Vector3f a_PlayerPos(a_ClosestPlayer->GetPosition());
 		a_PlayerPos.y++;
diff --git a/src/Entities/Floater.cpp b/src/Entities/Floater.cpp
index 159429147..5fe6a1238 100644
--- a/src/Entities/Floater.cpp
+++ b/src/Entities/Floater.cpp
@@ -22,7 +22,7 @@ public:
 		m_Pos(a_Pos),
 		m_NextPos(a_NextPos),
 		m_MinCoeff(1),
-		m_HitEntity(NULL)
+		m_HitEntity(nullptr)
 	{
 	}
 	virtual bool Item(cEntity * a_Entity) override
diff --git a/src/Entities/ItemFrame.cpp b/src/Entities/ItemFrame.cpp
index f512324eb..b7aac52d0 100644
--- a/src/Entities/ItemFrame.cpp
+++ b/src/Entities/ItemFrame.cpp
@@ -62,7 +62,7 @@ void cItemFrame::KilledBy(TakeDamageInfo & a_TDI)
 		return;
 	}
 
-	if ((a_TDI.Attacker != NULL) && a_TDI.Attacker->IsPlayer() && !((cPlayer *)a_TDI.Attacker)->IsGameModeCreative())
+	if ((a_TDI.Attacker != nullptr) && a_TDI.Attacker->IsPlayer() && !((cPlayer *)a_TDI.Attacker)->IsGameModeCreative())
 	{
 		cItems Item;
 		Item.push_back(m_Item);
@@ -83,7 +83,7 @@ void cItemFrame::KilledBy(TakeDamageInfo & a_TDI)
 
 void cItemFrame::GetDrops(cItems & a_Items, cEntity * a_Killer)
 {
-	if ((a_Killer != NULL) && a_Killer->IsPlayer() && !((cPlayer *)a_Killer)->IsGameModeCreative())
+	if ((a_Killer != nullptr) && a_Killer->IsPlayer() && !((cPlayer *)a_Killer)->IsGameModeCreative())
 	{
 		a_Items.push_back(cItem(E_ITEM_ITEM_FRAME));
 	}
diff --git a/src/Entities/Minecart.cpp b/src/Entities/Minecart.cpp
index f45e7bb69..22e046800 100644
--- a/src/Entities/Minecart.cpp
+++ b/src/Entities/Minecart.cpp
@@ -36,7 +36,7 @@ public:
 
 	virtual bool Item(cEntity * a_Entity) override
 	{
-		ASSERT(a_Entity != NULL);
+		ASSERT(a_Entity != nullptr);
 
 		if (!a_Entity->IsPlayer() && !a_Entity->IsMob() && !a_Entity->IsMinecart() && !a_Entity->IsBoat())
 		{
@@ -130,7 +130,7 @@ void cMinecart::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 	int RelPosX = POSX_TOINT - a_Chunk.GetPosX() * cChunkDef::Width;
 	int RelPosZ = POSZ_TOINT - a_Chunk.GetPosZ() * cChunkDef::Width;
 	cChunk * Chunk = a_Chunk.GetRelNeighborChunkAdjustCoords(RelPosX, RelPosZ);
-	if (Chunk == NULL)
+	if (Chunk == nullptr)
 	{
 		// Inside an unloaded chunk, bail out all processing
 		return;
@@ -806,7 +806,7 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
 
 bool cMinecart::TestEntityCollision(NIBBLETYPE a_RailMeta)
 {
-	cMinecartCollisionCallback MinecartCollisionCallback(GetPosition(), GetHeight(), GetWidth(), GetUniqueID(), ((m_Attachee == NULL) ? -1 : m_Attachee->GetUniqueID()));
+	cMinecartCollisionCallback MinecartCollisionCallback(GetPosition(), GetHeight(), GetWidth(), GetUniqueID(), ((m_Attachee == nullptr) ? -1 : m_Attachee->GetUniqueID()));
 	int ChunkX, ChunkZ;
 	cChunkDef::BlockToChunk(POSX_TOINT, POSZ_TOINT, ChunkX, ChunkZ);
 	m_World->ForEachEntityInChunk(ChunkX, ChunkZ, MinecartCollisionCallback);
@@ -980,7 +980,7 @@ bool cMinecart::TestEntityCollision(NIBBLETYPE a_RailMeta)
 
 bool cMinecart::DoTakeDamage(TakeDamageInfo & TDI)
 {
-	if ((TDI.Attacker != NULL) && TDI.Attacker->IsPlayer() && ((cPlayer *)TDI.Attacker)->IsGameModeCreative())
+	if ((TDI.Attacker != nullptr) && TDI.Attacker->IsPlayer() && ((cPlayer *)TDI.Attacker)->IsGameModeCreative())
 	{
 		Destroy();
 		TDI.FinalDamage = GetMaxHealth();  // Instant hit for creative
@@ -1074,7 +1074,7 @@ void cRideableMinecart::OnRightClicked(cPlayer & a_Player)
 {
 	super::OnRightClicked(a_Player);
 
-	if (m_Attachee != NULL)
+	if (m_Attachee != nullptr)
 	{
 		if (m_Attachee->GetUniqueID() == a_Player.GetUniqueID())
 		{
@@ -1120,14 +1120,14 @@ void cMinecartWithChest::OnRightClicked(cPlayer & a_Player)
 {
 	// If the window is not created, open it anew:
 	cWindow * Window = GetWindow();
-	if (Window == NULL)
+	if (Window == nullptr)
 	{
 		OpenNewWindow();
 		Window = GetWindow();
 	}
 
 	// Open the window for the player:
-	if (Window != NULL)
+	if (Window != nullptr)
 	{
 		if (a_Player.GetWindow() != Window)
 		{
diff --git a/src/Entities/Minecart.h b/src/Entities/Minecart.h
index ab906fd06..40e22c641 100644
--- a/src/Entities/Minecart.h
+++ b/src/Entities/Minecart.h
@@ -140,9 +140,9 @@ protected:
 	{
 		UNUSED(a_SlotNum);
 		ASSERT(a_Grid == &m_Contents);
-		if (m_World != NULL)
+		if (m_World != nullptr)
 		{
-			if (GetWindow() != NULL)
+			if (GetWindow() != nullptr)
 			{
 				GetWindow()->BroadcastWholeWindow();
 			}
diff --git a/src/Entities/Painting.cpp b/src/Entities/Painting.cpp
index e217556c7..1aa6da0a1 100644
--- a/src/Entities/Painting.cpp
+++ b/src/Entities/Painting.cpp
@@ -43,7 +43,7 @@ void cPainting::Tick(float a_Dt, cChunk & a_Chunk)
 
 void cPainting::GetDrops(cItems & a_Items, cEntity * a_Killer)
 {
-	if ((a_Killer != NULL) && a_Killer->IsPlayer() && !((cPlayer *)a_Killer)->IsGameModeCreative())
+	if ((a_Killer != nullptr) && a_Killer->IsPlayer() && !((cPlayer *)a_Killer)->IsGameModeCreative())
 	{
 		a_Items.push_back(cItem(E_ITEM_PAINTING));
 	}
diff --git a/src/Entities/Player.cpp b/src/Entities/Player.cpp
index 24daba048..b417feb86 100644
--- a/src/Entities/Player.cpp
+++ b/src/Entities/Player.cpp
@@ -55,8 +55,8 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName) :
 	m_Stance(0.0),
 	m_Inventory(*this),
 	m_EnderChestContents(9, 3),
-	m_CurrentWindow(NULL),
-	m_InventoryWindow(NULL),
+	m_CurrentWindow(nullptr),
+	m_InventoryWindow(nullptr),
 	m_GameMode(eGameMode_NotSet),
 	m_IP(""),
 	m_ClientHandle(a_Client),
@@ -77,10 +77,10 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName) :
 	m_IsChargingBow(false),
 	m_BowCharge(0),
 	m_FloaterID(-1),
-	m_Team(NULL),
+	m_Team(nullptr),
 	m_TicksUntilNextSave(PLAYER_INVENTORY_SAVE_INTERVAL),
 	m_bIsTeleporting(false),
-	m_UUID((a_Client != NULL) ? a_Client->GetUUID() : ""),
+	m_UUID((a_Client != nullptr) ? a_Client->GetUUID() : ""),
 	m_CustomName("")
 {
 	m_InventoryWindow = new cInventoryWindow(*this);
@@ -93,7 +93,7 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName) :
 	m_LastPlayerListTime = std::chrono::steady_clock::now();
 	m_PlayerName = a_PlayerName;
 
-	cWorld * World = NULL;
+	cWorld * World = nullptr;
 	if (!LoadFromDisk(World))
 	{
 		m_Inventory.Clear();
@@ -141,10 +141,10 @@ cPlayer::~cPlayer(void)
 
 	SaveToDisk();
 
-	m_ClientHandle = NULL;
+	m_ClientHandle = nullptr;
 	
 	delete m_InventoryWindow;
-	m_InventoryWindow = NULL;
+	m_InventoryWindow = nullptr;
 	
 	LOGD("Player %p deleted", this);
 }
@@ -183,12 +183,12 @@ void cPlayer::SpawnOn(cClientHandle & a_Client)
 
 void cPlayer::Tick(float a_Dt, cChunk & a_Chunk)
 {
-	if (m_ClientHandle != NULL)
+	if (m_ClientHandle != nullptr)
 	{
 		if (m_ClientHandle->IsDestroyed())
 		{
 			// This should not happen, because destroying a client will remove it from the world, but just in case
-			m_ClientHandle = NULL;
+			m_ClientHandle = nullptr;
 			return;
 		}
 		
@@ -500,7 +500,7 @@ void cPlayer::SetTouchGround(bool a_bTouchGround)
 		if (Damage > 0)
 		{
 			// cPlayer makes sure damage isn't applied in creative, no need to check here
-			TakeDamage(dtFalling, NULL, Damage, Damage, 0);
+			TakeDamage(dtFalling, nullptr, Damage, Damage, 0);
 			
 			// Fall particles
 			GetWorld()->BroadcastSoundParticleEffect(2006, POSX_TOINT, (int)GetPosY() - 1, POSZ_TOINT, Damage /* Used as particle effect speed modifier */);
@@ -647,7 +647,7 @@ void cPlayer::AbortEating(void)
 
 void cPlayer::SendHealth(void)
 {
-	if (m_ClientHandle != NULL)
+	if (m_ClientHandle != nullptr)
 	{
 		m_ClientHandle->SendHealth();
 	}
@@ -659,7 +659,7 @@ void cPlayer::SendHealth(void)
 
 void cPlayer::SendExperience(void)
 {
-	if (m_ClientHandle != NULL)
+	if (m_ClientHandle != nullptr)
 	{
 		m_ClientHandle->SendExperience();
 		m_bDirtyExperience = false;
@@ -855,11 +855,11 @@ bool cPlayer::DoTakeDamage(TakeDamageInfo & a_TDI)
 		}
 	}
 
-	if ((a_TDI.Attacker != NULL) && (a_TDI.Attacker->IsPlayer()))
+	if ((a_TDI.Attacker != nullptr) && (a_TDI.Attacker->IsPlayer()))
 	{
 		cPlayer * Attacker = (cPlayer *)a_TDI.Attacker;
 
-		if ((m_Team != NULL) && (m_Team == Attacker->m_Team))
+		if ((m_Team != nullptr) && (m_Team == Attacker->m_Team))
 		{
 			if (!m_Team->AllowsFriendlyFire())
 			{
@@ -911,7 +911,7 @@ void cPlayer::KilledBy(TakeDamageInfo & a_TDI)
 	m_World->SpawnItemPickups(Pickups, GetPosX(), GetPosY(), GetPosZ(), 10);
 	SaveToDisk();  // Save it, yeah the world is a tough place !
 
-	if ((a_TDI.Attacker == NULL) && m_World->ShouldBroadcastDeathMessages())
+	if ((a_TDI.Attacker == nullptr) && m_World->ShouldBroadcastDeathMessages())
 	{
 		AString DamageText;
 		switch (a_TDI.DamageType)
@@ -937,7 +937,7 @@ void cPlayer::KilledBy(TakeDamageInfo & a_TDI)
 		}
 		GetWorld()->BroadcastChatDeath(Printf("%s %s", GetName().c_str(), DamageText.c_str()));
 	}
-	else if (a_TDI.Attacker == NULL)  // && !m_World->ShouldBroadcastDeathMessages() by fallthrough
+	else if (a_TDI.Attacker == nullptr)  // && !m_World->ShouldBroadcastDeathMessages() by fallthrough
 	{
 		// no-op
 	}
@@ -993,7 +993,7 @@ void cPlayer::Killed(cEntity * a_Victim)
 
 void cPlayer::Respawn(void)
 {
-	ASSERT(m_World != NULL);
+	ASSERT(m_World != nullptr);
 
 	m_Health = GetMaxHealth();
 	SetInvulnerableTicks(20);
@@ -1103,9 +1103,9 @@ void cPlayer::SetTeam(cTeam * a_Team)
 
 cTeam * cPlayer::UpdateTeam(void)
 {
-	if (m_World == NULL)
+	if (m_World == nullptr)
 	{
-		SetTeam(NULL);
+		SetTeam(nullptr);
 	}
 	else
 	{
@@ -1138,7 +1138,7 @@ void cPlayer::OpenWindow(cWindow * a_Window)
 
 void cPlayer::CloseWindow(bool a_CanRefuse)
 {
-	if (m_CurrentWindow == NULL)
+	if (m_CurrentWindow == nullptr)
 	{
 		m_CurrentWindow = m_InventoryWindow;
 		return;
@@ -1163,7 +1163,7 @@ void cPlayer::CloseWindow(bool a_CanRefuse)
 
 void cPlayer::CloseWindowIfID(char a_WindowID, bool a_CanRefuse)
 {
-	if ((m_CurrentWindow == NULL) || (m_CurrentWindow->GetWindowID() != a_WindowID))
+	if ((m_CurrentWindow == nullptr) || (m_CurrentWindow->GetWindowID() != a_WindowID))
 	{
 		return;
 	}
@@ -1350,7 +1350,7 @@ void cPlayer::MoveTo( const Vector3d & a_NewPos)
 		// Y = -999 and X, Z = attempting to create speed, usually up to 0.03
 		// We cannot test m_AttachedTo, because when deattaching, the server thinks the client is already deattached while
 		// the client may still send more of these nonsensical packets.
-		if (m_AttachedTo != NULL)
+		if (m_AttachedTo != nullptr)
 		{
 			Vector3d AddSpeed(a_NewPos);
 			AddSpeed.y = 0;
@@ -1577,7 +1577,7 @@ void cPlayer::TossItems(const cItems & a_Items)
 
 bool cPlayer::DoMoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn)
 {
-	ASSERT(a_World != NULL);
+	ASSERT(a_World != nullptr);
 
 	if (GetWorld() == a_World)
 	{
@@ -1586,7 +1586,7 @@ bool cPlayer::DoMoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn)
 	}
 	
 	// Send the respawn packet:
-	if (a_ShouldSendRespawn && (m_ClientHandle != NULL))
+	if (a_ShouldSendRespawn && (m_ClientHandle != nullptr))
 	{
 		m_ClientHandle->SendRespawn(a_World->GetDimension());
 	}
@@ -1648,7 +1648,7 @@ bool cPlayer::LoadFromDisk(cWorldPtr & a_World)
 		GetName().c_str(), m_UUID.c_str(), OfflineUUID.c_str(), OfflineUsage
 	);
 
-	if (a_World == NULL)
+	if (a_World == nullptr)
 	{
 		a_World = cRoot::Get()->GetDefaultWorld();
 	}
@@ -1725,7 +1725,7 @@ bool cPlayer::LoadFromFile(const AString & a_FileName, cWorldPtr & a_World)
 
 	m_LoadedWorldName = root.get("world", "world").asString();
 	a_World = cRoot::Get()->GetWorld(GetLoadedWorldName(), false);
-	if (a_World == NULL)
+	if (a_World == nullptr)
 	{
 		a_World = cRoot::Get()->GetDefaultWorld();
 	}
@@ -1791,7 +1791,7 @@ bool cPlayer::SaveToDisk()
 	root["SpawnY"]              = GetLastBedPos().y;
 	root["SpawnZ"]              = GetLastBedPos().z;
 
-	if (m_World != NULL)
+	if (m_World != nullptr)
 	{
 		root["world"] = m_World->GetName();
 		if (m_GameMode == m_World->GetGameMode())
@@ -1945,7 +1945,7 @@ void cPlayer::HandleFood(void)
 			else if ((m_FoodLevel <= 0) && (m_Health > 1))
 			{
 				// Damage from starving
-				TakeDamage(dtStarving, NULL, 1, 1, 0);
+				TakeDamage(dtStarving, nullptr, 1, 1, 0);
 			}
 		}
 	}
@@ -2014,7 +2014,7 @@ void cPlayer::UpdateMovementStats(const Vector3d & a_DeltaPos)
 {
 	StatValue Value = (StatValue)floor(a_DeltaPos.Length() * 100 + 0.5);
 
-	if (m_AttachedTo == NULL)
+	if (m_AttachedTo == nullptr)
 	{
 		if (IsClimbing())
 		{
@@ -2087,7 +2087,7 @@ void cPlayer::ApplyFoodExhaustionFromMovement()
 	}
 
 	// If riding anything, apply no food exhaustion
-	if (m_AttachedTo != NULL)
+	if (m_AttachedTo != nullptr)
 	{
 		return;
 	}
diff --git a/src/Entities/Player.h b/src/Entities/Player.h
index 8dd5bdb19..c643aaa8e 100644
--- a/src/Entities/Player.h
+++ b/src/Entities/Player.h
@@ -176,10 +176,10 @@ public:
 	
 	AString GetIP(void) const { return m_IP; }  // tolua_export
 
-	/** Returns the associated team, NULL if none */
+	/** Returns the associated team, nullptr if none */
 	cTeam * GetTeam(void) { return m_Team; }  // tolua_export
 
-	/** Sets the player team, NULL if none */
+	/** Sets the player team, nullptr if none */
 	void SetTeam(cTeam * a_Team);
 
 	// tolua_end
diff --git a/src/Entities/ProjectileEntity.cpp b/src/Entities/ProjectileEntity.cpp
index ab25ac30c..1768714f8 100644
--- a/src/Entities/ProjectileEntity.cpp
+++ b/src/Entities/ProjectileEntity.cpp
@@ -135,7 +135,7 @@ public:
 		m_Pos(a_Pos),
 		m_NextPos(a_NextPos),
 		m_MinCoeff(1),
-		m_HitEntity(NULL)
+		m_HitEntity(nullptr)
 	{
 	}
 	
@@ -221,9 +221,9 @@ cProjectileEntity::cProjectileEntity(eKind a_Kind, cEntity * a_Creator, double a
 	super(etProjectile, a_X, a_Y, a_Z, a_Width, a_Height),
 	m_ProjectileKind(a_Kind),
 	m_CreatorData(
-		((a_Creator != NULL) ? a_Creator->GetUniqueID() : -1),
-		((a_Creator != NULL) ? (a_Creator->IsPlayer() ? ((cPlayer *)a_Creator)->GetName() : "") : ""),
-		((a_Creator != NULL) ? a_Creator->GetEquippedWeapon().m_Enchantments : cEnchantments())
+		((a_Creator != nullptr) ? a_Creator->GetUniqueID() : -1),
+		((a_Creator != nullptr) ? (a_Creator->IsPlayer() ? ((cPlayer *)a_Creator)->GetName() : "") : ""),
+		((a_Creator != nullptr) ? a_Creator->GetEquippedWeapon().m_Enchantments : cEnchantments())
 	),
 	m_IsInGround(false)
 {
@@ -251,7 +251,7 @@ cProjectileEntity::cProjectileEntity(eKind a_Kind, cEntity * a_Creator, const Ve
 cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem * a_Item, const Vector3d * a_Speed)
 {
 	Vector3d Speed;
-	if (a_Speed != NULL)
+	if (a_Speed != nullptr)
 	{
 		Speed = *a_Speed;
 	}
@@ -269,10 +269,10 @@ cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator,
 		case pkWitherSkull:   return new cWitherSkullEntity     (a_Creator, a_X, a_Y, a_Z, Speed);
 		case pkFirework:
 		{
-			ASSERT(a_Item != NULL);
+			ASSERT(a_Item != nullptr);
 			if (a_Item->m_FireworkItem.m_Colours.empty())
 			{
-				return NULL;
+				return nullptr;
 			}
 
 			return new cFireworkEntity(a_Creator, a_X, a_Y, a_Z, *a_Item);
@@ -280,7 +280,7 @@ cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator,
 	}
 	
 	LOGWARNING("%s: Unknown projectile kind: %d", __FUNCTION__, a_Kind);
-	return NULL;
+	return nullptr;
 }
 
 
diff --git a/src/Entities/ProjectileEntity.h b/src/Entities/ProjectileEntity.h
index 03eda9739..3861f9ecc 100644
--- a/src/Entities/ProjectileEntity.h
+++ b/src/Entities/ProjectileEntity.h
@@ -46,7 +46,7 @@ public:
 	cProjectileEntity(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, double a_Width, double a_Height);
 	cProjectileEntity(eKind a_Kind, cEntity * a_Creator, const Vector3d & a_Pos, const Vector3d & a_Speed, double a_Width, double a_Height);
 	
-	static cProjectileEntity * Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem * a_Item, const Vector3d * a_Speed = NULL);
+	static cProjectileEntity * Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem * a_Item, const Vector3d * a_Speed = nullptr);
 	
 	/// Called by the physics blocktracer when the entity hits a solid block, the hit position and the face hit (BLOCK_FACE_) is given
 	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace);
@@ -110,7 +110,7 @@ protected:
 	eKind m_ProjectileKind;
 	
 	/** The structure for containing the entity ID and name who has created this projectile
-	The ID and/or name may be NULL (e.g. for dispensers/mobs)
+	The ID and/or name may be nullptr (e.g. for dispensers/mobs)
 	*/
 	CreatorData m_CreatorData;
 	
diff --git a/src/FurnaceRecipe.cpp b/src/FurnaceRecipe.cpp
index d200ef3d7..9b3b2ecbe 100644
--- a/src/FurnaceRecipe.cpp
+++ b/src/FurnaceRecipe.cpp
@@ -43,7 +43,7 @@ cFurnaceRecipe::~cFurnaceRecipe()
 {
 	ClearRecipes();
 	delete m_pState;
-	m_pState = NULL;
+	m_pState = nullptr;
 }
 
 
@@ -247,9 +247,9 @@ void cFurnaceRecipe::ClearRecipes(void)
 	{
 		cRecipe Recipe = *itr;
 		delete Recipe.In;
-		Recipe.In = NULL;
+		Recipe.In = nullptr;
 		delete Recipe.Out;
-		Recipe.Out = NULL;
+		Recipe.Out = nullptr;
 	}
 	m_pState->Recipes.clear();
 
@@ -257,7 +257,7 @@ void cFurnaceRecipe::ClearRecipes(void)
 	{
 		cFuel Fuel = *itr;
 		delete Fuel.In;
-		Fuel.In = NULL;
+		Fuel.In = nullptr;
 	}
 	m_pState->Fuel.clear();
 }
diff --git a/src/FurnaceRecipe.h b/src/FurnaceRecipe.h
index 6a1650695..936ef706d 100644
--- a/src/FurnaceRecipe.h
+++ b/src/FurnaceRecipe.h
@@ -32,7 +32,7 @@ public:
 		int CookTime;  ///< How long this recipe takes to smelt, in ticks
 	};
 	
-	/** Returns a recipe for the specified input, NULL if no recipe found */
+	/** Returns a recipe for the specified input, nullptr if no recipe found */
 	const cRecipe * GetRecipeFrom(const cItem & a_Ingredient) const;
 	
 	/** Returns the amount of time that the specified fuel burns, in ticks */
diff --git a/src/Generating/BioGen.cpp b/src/Generating/BioGen.cpp
index b9face1f8..d86d44bbc 100644
--- a/src/Generating/BioGen.cpp
+++ b/src/Generating/BioGen.cpp
@@ -69,9 +69,9 @@ cBioGenCache::cBioGenCache(cBiomeGenPtr a_BioGenToCache, int a_CacheSize) :
 cBioGenCache::~cBioGenCache()
 {
 	delete[] m_CacheData;
-	m_CacheData = NULL;
+	m_CacheData = nullptr;
 	delete[] m_CacheOrder;
-	m_CacheOrder = NULL;
+	m_CacheOrder = nullptr;
 }
 
 
@@ -928,7 +928,7 @@ cBiomeGenPtr cBiomeGen::CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool &
 		BiomeGenName = "MultiStepMap";
 	}
 
-	cBiomeGen * res = NULL;
+	cBiomeGen * res = nullptr;
 	a_CacheOffByDefault = false;
 	if (NoCaseCompare(BiomeGenName, "constant") == 0)
 	{
diff --git a/src/Generating/ChunkDesc.cpp b/src/Generating/ChunkDesc.cpp
index 566332b1f..020d3bd0f 100644
--- a/src/Generating/ChunkDesc.cpp
+++ b/src/Generating/ChunkDesc.cpp
@@ -530,10 +530,10 @@ cBlockEntity * cChunkDesc::GetBlockEntity(int a_RelX, int a_RelY, int a_RelZ)
 	
 	// The block entity is not created yet, try to create it and add to list:
 	cBlockEntity * be = cBlockEntity::CreateByBlockType(GetBlockType(a_RelX, a_RelY, a_RelZ), GetBlockMeta(a_RelX, a_RelY, a_RelZ), AbsX, a_RelY, AbsZ);
-	if (be == NULL)
+	if (be == nullptr)
 	{
 		// No block entity for this block type
-		return NULL;
+		return nullptr;
 	}
 	m_BlockEntities.push_back(be);
 	return be;
diff --git a/src/Generating/ChunkDesc.h b/src/Generating/ChunkDesc.h
index eeea0c957..570132790 100644
--- a/src/Generating/ChunkDesc.h
+++ b/src/Generating/ChunkDesc.h
@@ -172,7 +172,7 @@ public:
 	
 	/** Returns the block entity at the specified coords.
 	If there is no block entity at those coords, tries to create one, based on the block type
-	If the blocktype doesn't support a block entity, returns NULL. */
+	If the blocktype doesn't support a block entity, returns nullptr. */
 	cBlockEntity * GetBlockEntity(int a_RelX, int a_RelY, int a_RelZ);
 	
 	/** Updates the heightmap to match the current contents.
diff --git a/src/Generating/ChunkGenerator.cpp b/src/Generating/ChunkGenerator.cpp
index 20b6b7066..b08b9411e 100644
--- a/src/Generating/ChunkGenerator.cpp
+++ b/src/Generating/ChunkGenerator.cpp
@@ -28,9 +28,9 @@ const unsigned int QUEUE_SKIP_LIMIT = 500;
 cChunkGenerator::cChunkGenerator(void) :
 	super("cChunkGenerator"),
 	m_Seed(0),  // Will be overwritten by the actual generator
-	m_Generator(NULL),
-	m_PluginInterface(NULL),
-	m_ChunkSink(NULL)
+	m_Generator(nullptr),
+	m_PluginInterface(nullptr),
+	m_ChunkSink(nullptr)
 {
 }
 
@@ -80,7 +80,7 @@ bool cChunkGenerator::Start(cPluginInterface & a_PluginInterface, cChunkSink & a
 		m_Generator = new cComposableGenerator(*this);
 	}
 
-	if (m_Generator == NULL)
+	if (m_Generator == nullptr)
 	{
 		LOGERROR("Generator could not start, aborting the server");
 		return false;
@@ -103,7 +103,7 @@ void cChunkGenerator::Stop(void)
 	Wait();
 
 	delete m_Generator;
-	m_Generator = NULL;
+	m_Generator = nullptr;
 }
 
 
@@ -144,7 +144,7 @@ void cChunkGenerator::QueueGenerateChunk(int a_ChunkX, int a_ChunkZ, bool a_Forc
 
 void cChunkGenerator::GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap)
 {
-	if (m_Generator != NULL)
+	if (m_Generator != nullptr)
 	{
 		m_Generator->GenerateBiomes(a_ChunkX, a_ChunkZ, a_BiomeMap);
 	}
@@ -180,7 +180,7 @@ int cChunkGenerator::GetQueueLength(void)
 
 EMCSBiome cChunkGenerator::GetBiomeAt(int a_BlockX, int a_BlockZ)
 {
-	ASSERT(m_Generator != NULL);
+	ASSERT(m_Generator != nullptr);
 	return m_Generator->GetBiomeAt(a_BlockX, a_BlockZ);
 }
 
@@ -283,8 +283,8 @@ void cChunkGenerator::Execute(void)
 
 void cChunkGenerator::DoGenerate(int a_ChunkX, int a_ChunkZ)
 {
-	ASSERT(m_PluginInterface != NULL);
-	ASSERT(m_ChunkSink != NULL);
+	ASSERT(m_PluginInterface != nullptr);
+	ASSERT(m_ChunkSink != nullptr);
 	ASSERT(m_ChunkSink->IsChunkQueued(a_ChunkX, a_ChunkZ));
 
 	cChunkDesc ChunkDesc(a_ChunkX, a_ChunkZ);
diff --git a/src/Generating/CompoGen.cpp b/src/Generating/CompoGen.cpp
index 0105fdb70..2c88f23f1 100644
--- a/src/Generating/CompoGen.cpp
+++ b/src/Generating/CompoGen.cpp
@@ -687,9 +687,9 @@ cCompoGenCache::cCompoGenCache(cTerrainCompositionGenPtr a_Underlying, int a_Cac
 cCompoGenCache::~cCompoGenCache()
 {
 	delete[] m_CacheData;
-	m_CacheData = NULL;
+	m_CacheData = nullptr;
 	delete[] m_CacheOrder;
-	m_CacheOrder = NULL;
+	m_CacheOrder = nullptr;
 }
 
 
diff --git a/src/Generating/ComposableGenerator.cpp b/src/Generating/ComposableGenerator.cpp
index 358d97c92..625dffa84 100644
--- a/src/Generating/ComposableGenerator.cpp
+++ b/src/Generating/ComposableGenerator.cpp
@@ -48,7 +48,7 @@ cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(cIniFile
 		CompoGenName = "Biomal";
 	}
 	
-	cTerrainCompositionGen * res = NULL;
+	cTerrainCompositionGen * res = nullptr;
 	if (NoCaseCompare(CompoGenName, "sameblock") == 0)
 	{
 		res = new cCompoGenSameBlock;
@@ -102,7 +102,7 @@ cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(cIniFile
 		a_IniFile.SetValue("Generator", "CompositionGen", "Biomal");
 		return CreateCompositionGen(a_IniFile, a_BiomeGen, a_HeightGen, a_Seed);
 	}
-	ASSERT(res != NULL);
+	ASSERT(res != nullptr);
 	
 	// Read the settings from the ini file:
 	res->InitializeCompoGen(a_IniFile);
@@ -145,7 +145,7 @@ void cComposableGenerator::Initialize(cIniFile & a_IniFile)
 
 void cComposableGenerator::GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap)
 {
-	if (m_BiomeGen != NULL)  // Quick fix for generator deinitializing before the world storage finishes loading
+	if (m_BiomeGen != nullptr)  // Quick fix for generator deinitializing before the world storage finishes loading
 	{
 		m_BiomeGen->GenBiomes(a_ChunkX, a_ChunkZ, a_BiomeMap);
 	}
diff --git a/src/Generating/DungeonRoomsFinisher.cpp b/src/Generating/DungeonRoomsFinisher.cpp
index 93fe8b472..3f328868d 100644
--- a/src/Generating/DungeonRoomsFinisher.cpp
+++ b/src/Generating/DungeonRoomsFinisher.cpp
@@ -198,7 +198,7 @@ protected:
 		} ;
 
 		cChestEntity * ChestEntity = (cChestEntity *)a_ChunkDesc.GetBlockEntity(RelX, m_FloorHeight + 1, RelZ);
-		ASSERT((ChestEntity != NULL) && (ChestEntity->GetBlockType() == E_BLOCK_CHEST));
+		ASSERT((ChestEntity != nullptr) && (ChestEntity->GetBlockType() == E_BLOCK_CHEST));
 		cNoise Noise(a_ChunkDesc.GetChunkX() ^ a_ChunkDesc.GetChunkZ());
 		int NumSlots = 3 + ((Noise.IntNoise3DInt(a_Chest.x, a_Chest.y, a_Chest.z) / 11) % 4);
 		int Seed = Noise.IntNoise2DInt(RelX, RelZ);
diff --git a/src/Generating/GridStructGen.cpp b/src/Generating/GridStructGen.cpp
index 7090f14b1..3c08c1a39 100644
--- a/src/Generating/GridStructGen.cpp
+++ b/src/Generating/GridStructGen.cpp
@@ -135,7 +135,7 @@ void cGridStructGen::GetStructuresForChunk(int a_ChunkX, int a_ChunkZ, cStructur
 				int OriginX = GridX + ((m_Noise.IntNoise2DInt(GridX + 3, GridZ + 5) / 7) % (m_MaxOffsetX * 2)) - m_MaxOffsetX;
 				int OriginZ = GridZ + ((m_Noise.IntNoise2DInt(GridX + 5, GridZ + 3) / 7) % (m_MaxOffsetZ * 2)) - m_MaxOffsetZ;
 				cStructurePtr Structure = CreateStructure(GridX, GridZ, OriginX, OriginZ);
-				if (Structure.get() == NULL)
+				if (Structure.get() == nullptr)
 				{
 					Structure.reset(new cEmptyStructure(GridX, GridZ, OriginX, OriginZ));
 				}
diff --git a/src/Generating/HeiGen.cpp b/src/Generating/HeiGen.cpp
index b7d4b337c..acfefaefc 100644
--- a/src/Generating/HeiGen.cpp
+++ b/src/Generating/HeiGen.cpp
@@ -29,7 +29,7 @@ cTerrainHeightGenPtr cTerrainHeightGen::CreateHeightGen(cIniFile & a_IniFile, cB
 	}
 	
 	a_CacheOffByDefault = false;
-	cTerrainHeightGen * res = NULL;
+	cTerrainHeightGen * res = nullptr;
 	if (NoCaseCompare(HeightGenName, "flat") == 0)
 	{
 		res = new cHeiGenFlat;
@@ -142,9 +142,9 @@ cHeiGenCache::cHeiGenCache(cTerrainHeightGenPtr a_HeiGenToCache, int a_CacheSize
 cHeiGenCache::~cHeiGenCache()
 {
 	delete[] m_CacheData;
-	m_CacheData = NULL;
+	m_CacheData = nullptr;
 	delete[] m_CacheOrder;
-	m_CacheOrder = NULL;
+	m_CacheOrder = nullptr;
 }
 
 
diff --git a/src/Generating/MineShafts.cpp b/src/Generating/MineShafts.cpp
index 0532aff39..55b3b64dd 100644
--- a/src/Generating/MineShafts.cpp
+++ b/src/Generating/MineShafts.cpp
@@ -112,7 +112,7 @@ class cMineShaftCorridor :
 public:
 	/** Creates a new Corridor attached to the specified pivot point and direction.
 	Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.
-	May return NULL if cannot fit.
+	May return nullptr if cannot fit.
 	*/
 	static cMineShaft * CreateAndFit(
 		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
@@ -165,7 +165,7 @@ class cMineShaftCrossing :
 public:
 	/** Creates a new Crossing attached to the specified pivot point and direction.
 	Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.
-	May return NULL if cannot fit.
+	May return nullptr if cannot fit.
 	*/
 	static cMineShaft * CreateAndFit(
 		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
@@ -199,7 +199,7 @@ public:
 
 	/** Creates a new Staircase attached to the specified pivot point and direction.
 	Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.
-	May return NULL if cannot fit.
+	May return nullptr if cannot fit.
 	*/
 	static cMineShaft * CreateAndFit(
 		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
@@ -351,7 +351,7 @@ void cStructGenMineShafts::cMineShaftSystem::AppendBranch(
 		return;
 	}
 
-	cMineShaft * Next = NULL;
+	cMineShaft * Next = nullptr;
 	int rnd = (a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_RecursionLevel * 16, a_PivotZ) / 13) % m_ProbLevelStaircase;
 	if (rnd < m_ProbLevelCorridor)
 	{
@@ -365,7 +365,7 @@ void cStructGenMineShafts::cMineShaftSystem::AppendBranch(
 	{
 		Next = cMineShaftStaircase::CreateAndFit(*this, a_PivotX, a_PivotY, a_PivotZ, a_Direction, a_Noise);
 	}
-	if (Next == NULL)
+	if (Next == nullptr)
 	{
 		return;
 	}
@@ -552,7 +552,7 @@ cMineShaft * cMineShaftCorridor::CreateAndFit(
 	}
 	if (!a_ParentSystem.CanAppend(BoundingBox))
 	{
-		return NULL;
+		return nullptr;
 	}
 	return new cMineShaftCorridor(a_ParentSystem, BoundingBox, NumSegments, a_Direction, a_Noise);
 }
@@ -796,7 +796,7 @@ void cMineShaftCorridor::PlaceChest(cChunkDesc & a_ChunkDesc)
 	{
 		a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p1.y + 1, z, E_BLOCK_CHEST, Meta);
 		cChestEntity * ChestEntity = (cChestEntity *)a_ChunkDesc.GetBlockEntity(x, m_BoundingBox.p1.y + 1, z);
-		ASSERT((ChestEntity != NULL) && (ChestEntity->GetBlockType() == E_BLOCK_CHEST));
+		ASSERT((ChestEntity != nullptr) && (ChestEntity->GetBlockType() == E_BLOCK_CHEST));
 		cNoise Noise(a_ChunkDesc.GetChunkX() ^ a_ChunkDesc.GetChunkZ());
 		int NumSlots = 3 + ((Noise.IntNoise3DInt(x, m_BoundingBox.p1.y, z) / 11) % 4);
 		int Seed = Noise.IntNoise2DInt(x, z);
@@ -1006,7 +1006,7 @@ cMineShaft * cMineShaftCrossing::CreateAndFit(
 	}
 	if (!a_ParentSystem.CanAppend(BoundingBox))
 	{
-		return NULL;
+		return nullptr;
 	}
 	return new cMineShaftCrossing(a_ParentSystem, BoundingBox);
 }
@@ -1157,7 +1157,7 @@ cMineShaft * cMineShaftStaircase::CreateAndFit(
 	}
 	if (!a_ParentSystem.CanAppend(Box))
 	{
-		return NULL;
+		return nullptr;
 	}
 	return new cMineShaftStaircase(a_ParentSystem, Box, a_Direction, Slope);
 }
diff --git a/src/Generating/PieceGenerator.cpp b/src/Generating/PieceGenerator.cpp
index ae4b6e36c..97aa646fc 100644
--- a/src/Generating/PieceGenerator.cpp
+++ b/src/Generating/PieceGenerator.cpp
@@ -289,7 +289,7 @@ cPlacedPiece::cPlacedPiece(const cPlacedPiece * a_Parent, const cPiece & a_Piece
 	m_NumCCWRotations(a_NumCCWRotations),
 	m_HasBeenMovedToGround(false)
 {
-	m_Depth = (m_Parent == NULL) ? 0 : (m_Parent->GetDepth() + 1);
+	m_Depth = (m_Parent == nullptr) ? 0 : (m_Parent->GetDepth() + 1);
 	m_HitBox = a_Piece.RotateMoveHitBox(a_NumCCWRotations, a_Coords.x, a_Coords.y, a_Coords.z);
 	m_HitBox.Sort();
 }
@@ -402,7 +402,7 @@ cPlacedPiece * cPieceGenerator::PlaceStartingPiece(int a_BlockX, int a_BlockY, i
 	}
 	int Rotation = Rotations[rnd % NumRotations];
 	
-	cPlacedPiece * res = new cPlacedPiece(NULL, *StartingPiece, Vector3i(a_BlockX, a_BlockY, a_BlockZ), Rotation);
+	cPlacedPiece * res = new cPlacedPiece(nullptr, *StartingPiece, Vector3i(a_BlockX, a_BlockY, a_BlockZ), Rotation);
 
 	// Place the piece's connectors into a_OutConnectors:
 	const cPiece::cConnectors & Conn = StartingPiece->GetConnectors();
diff --git a/src/Generating/Prefab.cpp b/src/Generating/Prefab.cpp
index 6da3c3d10..761986690 100644
--- a/src/Generating/Prefab.cpp
+++ b/src/Generating/Prefab.cpp
@@ -328,7 +328,7 @@ void cPrefab::AddConnector(int a_RelX, int a_RelY, int a_RelZ, eBlockFace a_Dire
 
 void cPrefab::ParseCharMap(CharMap & a_CharMapOut, const char * a_CharMapDef)
 {
-	ASSERT(a_CharMapDef != NULL);
+	ASSERT(a_CharMapDef != nullptr);
 	
 	// Initialize the charmap to all-invalid values:
 	for (size_t i = 0; i < ARRAYCOUNT(a_CharMapOut); i++)
@@ -389,7 +389,7 @@ void cPrefab::ParseBlockImage(const CharMap & a_CharMap, const char * a_BlockIma
 
 void cPrefab::ParseConnectors(const char * a_ConnectorsDef)
 {
-	ASSERT(a_ConnectorsDef != NULL);
+	ASSERT(a_ConnectorsDef != nullptr);
 	
 	AStringVector Lines = StringSplitAndTrim(a_ConnectorsDef, "\n");
 	for (AStringVector::const_iterator itr = Lines.begin(), end = Lines.end(); itr != end; ++itr)
@@ -436,7 +436,7 @@ void cPrefab::ParseConnectors(const char * a_ConnectorsDef)
 void cPrefab::ParseDepthWeight(const char * a_DepthWeightDef)
 {
 	// The member needn't be defined at all, if so, skip:
-	if (a_DepthWeightDef == NULL)
+	if (a_DepthWeightDef == nullptr)
 	{
 		return;
 	}
diff --git a/src/Generating/PrefabPiecePool.cpp b/src/Generating/PrefabPiecePool.cpp
index 122b9d2af..895555ef8 100644
--- a/src/Generating/PrefabPiecePool.cpp
+++ b/src/Generating/PrefabPiecePool.cpp
@@ -16,7 +16,7 @@ cPrefabPiecePool::cPrefabPiecePool(
 )
 {
 	AddPieceDefs(a_PieceDefs, a_NumPieceDefs);
-	if (a_StartingPieceDefs != NULL)
+	if (a_StartingPieceDefs != nullptr)
 	{
 		AddStartingPieceDefs(a_StartingPieceDefs, a_NumStartingPieceDefs);
 	}
@@ -56,7 +56,7 @@ void cPrefabPiecePool::Clear(void)
 
 void cPrefabPiecePool::AddPieceDefs(const cPrefab::sDef * a_PieceDefs, size_t a_NumPieceDefs)
 {
-	ASSERT(a_PieceDefs != NULL);
+	ASSERT(a_PieceDefs != nullptr);
 	for (size_t i = 0; i < a_NumPieceDefs; i++)
 	{
 		cPrefab * Prefab = new cPrefab(a_PieceDefs[i]);
@@ -71,7 +71,7 @@ void cPrefabPiecePool::AddPieceDefs(const cPrefab::sDef * a_PieceDefs, size_t a_
 
 void cPrefabPiecePool::AddStartingPieceDefs(const cPrefab::sDef * a_StartingPieceDefs, size_t a_NumStartingPieceDefs)
 {
-	ASSERT(a_StartingPieceDefs != NULL);
+	ASSERT(a_StartingPieceDefs != nullptr);
 	for (size_t i = 0; i < a_NumStartingPieceDefs; i++)
 	{
 		cPrefab * Prefab = new cPrefab(a_StartingPieceDefs[i]);
diff --git a/src/Generating/VillageGen.cpp b/src/Generating/VillageGen.cpp
index 1806fd427..a9b359b6a 100644
--- a/src/Generating/VillageGen.cpp
+++ b/src/Generating/VillageGen.cpp
@@ -385,7 +385,7 @@ cGridStructGen::cStructurePtr cVillageGen::CreateStructure(int a_GridX, int a_Gr
 
 	// Check if all the biomes are village-friendly:
 	// If just one is not, no village is created, because it's likely that an unfriendly biome is too close
-	cVillagePiecePool * VillagePrefabs = NULL;
+	cVillagePiecePool * VillagePrefabs = nullptr;
 	BLOCKTYPE RoadBlock = E_BLOCK_GRAVEL;
 	BLOCKTYPE WaterRoadBlock = E_BLOCK_PLANKS;
 	int rnd = m_Noise.IntNoise2DInt(a_OriginX, a_OriginZ) / 11;
@@ -432,7 +432,7 @@ cGridStructGen::cStructurePtr cVillageGen::CreateStructure(int a_GridX, int a_Gr
 	}
 	
 	// Create a village based on the chosen prefabs:
-	if (VillagePrefabs == NULL)
+	if (VillagePrefabs == nullptr)
 	{
 		return cStructurePtr();
 	}
diff --git a/src/HTTPServer/HTTPConnection.cpp b/src/HTTPServer/HTTPConnection.cpp
index bf46bb241..d5dbf0199 100644
--- a/src/HTTPServer/HTTPConnection.cpp
+++ b/src/HTTPServer/HTTPConnection.cpp
@@ -15,7 +15,7 @@
 cHTTPConnection::cHTTPConnection(cHTTPServer & a_HTTPServer) :
 	m_HTTPServer(a_HTTPServer),
 	m_State(wcsRecvHeaders),
-	m_CurrentRequest(NULL),
+	m_CurrentRequest(nullptr),
 	m_CurrentRequestBodyRemaining(0)
 {
 	// LOGD("HTTP: New connection at %p", this);
@@ -29,7 +29,7 @@ cHTTPConnection::~cHTTPConnection()
 {
 	// LOGD("HTTP: Connection deleting: %p", this);
 	delete m_CurrentRequest;
-	m_CurrentRequest = NULL;
+	m_CurrentRequest = nullptr;
 }
 
 
@@ -136,7 +136,7 @@ void cHTTPConnection::AwaitNextRequest(void)
 
 void cHTTPConnection::Terminate(void)
 {
-	if (m_CurrentRequest != NULL)
+	if (m_CurrentRequest != nullptr)
 	{
 		m_HTTPServer.RequestFinished(*this, *m_CurrentRequest);
 	}
@@ -153,7 +153,7 @@ bool cHTTPConnection::DataReceived(const char * a_Data, size_t a_Size)
 	{
 		case wcsRecvHeaders:
 		{
-			if (m_CurrentRequest == NULL)
+			if (m_CurrentRequest == nullptr)
 			{
 				m_CurrentRequest = new cHTTPRequest;
 			}
@@ -162,7 +162,7 @@ bool cHTTPConnection::DataReceived(const char * a_Data, size_t a_Size)
 			if (BytesConsumed == AString::npos)
 			{
 				delete m_CurrentRequest;
-				m_CurrentRequest = NULL;
+				m_CurrentRequest = nullptr;
 				m_State = wcsInvalid;
 				m_HTTPServer.CloseConnection(*this);
 				return true;
@@ -196,7 +196,7 @@ bool cHTTPConnection::DataReceived(const char * a_Data, size_t a_Size)
 
 		case wcsRecvBody:
 		{
-			ASSERT(m_CurrentRequest != NULL);
+			ASSERT(m_CurrentRequest != nullptr);
 			if (m_CurrentRequestBodyRemaining > 0)
 			{
 				size_t BytesToConsume = std::min(m_CurrentRequestBodyRemaining, (size_t)a_Size);
@@ -214,7 +214,7 @@ bool cHTTPConnection::DataReceived(const char * a_Data, size_t a_Size)
 					return true;
 				}
 				delete m_CurrentRequest;
-				m_CurrentRequest = NULL;
+				m_CurrentRequest = nullptr;
 			}
 			break;
 		}
@@ -243,7 +243,7 @@ void cHTTPConnection::GetOutgoingData(AString & a_Data)
 
 void cHTTPConnection::SocketClosed(void)
 {
-	if (m_CurrentRequest != NULL)
+	if (m_CurrentRequest != nullptr)
 	{
 		m_HTTPServer.RequestFinished(*this, *m_CurrentRequest);
 	}
diff --git a/src/HTTPServer/HTTPConnection.h b/src/HTTPServer/HTTPConnection.h
index 6ea8a1ae8..ccbf26466 100644
--- a/src/HTTPServer/HTTPConnection.h
+++ b/src/HTTPServer/HTTPConnection.h
@@ -31,10 +31,10 @@ public:
 	
 	enum eState
 	{
-		wcsRecvHeaders,  ///< Receiving request headers (m_CurrentRequest is created if NULL)
+		wcsRecvHeaders,  ///< Receiving request headers (m_CurrentRequest is created if nullptr)
 		wcsRecvBody,     ///< Receiving request body    (m_CurrentRequest is valid)
-		wcsRecvIdle,     ///< Has received the entire body, waiting to send the response (m_CurrentRequest == NULL)
-		wcsSendingResp,  ///< Sending response body     (m_CurrentRequest == NULL)
+		wcsRecvIdle,     ///< Has received the entire body, waiting to send the response (m_CurrentRequest == nullptr)
+		wcsSendingResp,  ///< Sending response body     (m_CurrentRequest == nullptr)
 		wcsInvalid,      ///< The request was malformed, the connection is closing
 	} ;
 	
diff --git a/src/HTTPServer/HTTPFormParser.cpp b/src/HTTPServer/HTTPFormParser.cpp
index c50c6dcf2..72872078b 100644
--- a/src/HTTPServer/HTTPFormParser.cpp
+++ b/src/HTTPServer/HTTPFormParser.cpp
@@ -86,7 +86,7 @@ void cHTTPFormParser::Parse(const char * a_Data, size_t a_Size)
 		}
 		case fpkMultipart:
 		{
-			ASSERT(m_MultipartParser.get() != NULL);
+			ASSERT(m_MultipartParser.get() != nullptr);
 			m_MultipartParser->Parse(a_Data, a_Size);
 			break;
 		}
@@ -145,7 +145,7 @@ bool cHTTPFormParser::HasFormData(const cHTTPRequest & a_Request)
 
 void cHTTPFormParser::BeginMultipart(const cHTTPRequest & a_Request)
 {
-	ASSERT(m_MultipartParser.get() == NULL);
+	ASSERT(m_MultipartParser.get() == nullptr);
 	m_MultipartParser.reset(new cMultipartParser(a_Request.GetContentType(), *this));
 }
 
diff --git a/src/HTTPServer/HTTPMessage.cpp b/src/HTTPServer/HTTPMessage.cpp
index 65d73fd87..f6c0204ae 100644
--- a/src/HTTPServer/HTTPMessage.cpp
+++ b/src/HTTPServer/HTTPMessage.cpp
@@ -70,7 +70,7 @@ cHTTPRequest::cHTTPRequest(void) :
 	super(mkRequest),
 	m_EnvelopeParser(*this),
 	m_IsValid(true),
-	m_UserData(NULL),
+	m_UserData(nullptr),
 	m_HasAuth(false),
 	m_AllowKeepAlive(false)
 {
diff --git a/src/HTTPServer/HTTPServer.cpp b/src/HTTPServer/HTTPServer.cpp
index 0c41b54b2..9ab030a1f 100644
--- a/src/HTTPServer/HTTPServer.cpp
+++ b/src/HTTPServer/HTTPServer.cpp
@@ -44,7 +44,7 @@ class cDebugCallbacks :
 			UNUSED(a_Connection);
 			
 			cHTTPFormParser * FormParser = (cHTTPFormParser *)(a_Request.GetUserData());
-			if (FormParser != NULL)
+			if (FormParser != nullptr)
 			{
 				FormParser->Parse(a_Data, a_Size);
 			}
@@ -54,7 +54,7 @@ class cDebugCallbacks :
 		virtual void OnRequestFinished(cHTTPConnection & a_Connection, cHTTPRequest & a_Request) override
 		{
 			cHTTPFormParser * FormParser = (cHTTPFormParser *)(a_Request.GetUserData());
-			if (FormParser != NULL)
+			if (FormParser != nullptr)
 			{
 				if (FormParser->Finish())
 				{
@@ -124,7 +124,7 @@ class cDebugCallbacks :
 cHTTPServer::cHTTPServer(void) :
 	m_ListenThreadIPv4(*this, cSocket::IPv4, "WebServer"),
 	m_ListenThreadIPv6(*this, cSocket::IPv6, "WebServer"),
-	m_Callbacks(NULL)
+	m_Callbacks(nullptr)
 {
 }
 
@@ -168,7 +168,7 @@ bool cHTTPServer::Initialize(const AString & a_PortsIPv4, const AString & a_Port
 	}
 
 	// Notify the admin about the HTTPS / HTTP status
-	if (m_Cert.get() == NULL)
+	if (m_Cert.get() == nullptr)
 	{
 		LOGWARNING("WebServer: The server is running in unsecured HTTP mode.");
 		LOGINFO("Put a valid HTTPS certificate in file 'webadmin/httpscert.crt' and its corresponding private key to 'webadmin/httpskey.pem' (without any password) to enable HTTPS support");
@@ -235,7 +235,7 @@ void cHTTPServer::Stop(void)
 void cHTTPServer::OnConnectionAccepted(cSocket & a_Socket)
 {
 	cHTTPConnection * Connection;
-	if (m_Cert.get() != NULL)
+	if (m_Cert.get() != nullptr)
 	{
 		Connection = new cSslHTTPConnection(*this, m_Cert, m_CertPrivKey);
 	}
diff --git a/src/Inventory.cpp b/src/Inventory.cpp
index 832a079bc..51ac32da9 100644
--- a/src/Inventory.cpp
+++ b/src/Inventory.cpp
@@ -220,7 +220,7 @@ void cInventory::SetSlot(int a_SlotNum, const cItem & a_Item)
 
 	int GridSlotNum = 0;
 	cItemGrid * Grid = GetGridForSlotNum(a_SlotNum, GridSlotNum);
-	if (Grid == NULL)
+	if (Grid == nullptr)
 	{
 		LOGWARNING("%s(%d): requesting an invalid itemgrid. Ignoring.", __FUNCTION__, a_SlotNum);
 		return;
@@ -278,7 +278,7 @@ const cItem & cInventory::GetSlot(int a_SlotNum) const
 	}
 	int GridSlotNum = 0;
 	const cItemGrid * Grid = GetGridForSlotNum(a_SlotNum, GridSlotNum);
-	if (Grid == NULL)
+	if (Grid == nullptr)
 	{
 		// Something went wrong, but we don't know what. We must return a value, so return the first inventory slot
 		LOGWARNING("%s(%d): requesting an invalid ItemGrid, returning the first inventory slot instead.", __FUNCTION__, a_SlotNum);
@@ -372,7 +372,7 @@ int cInventory::ChangeSlotCount(int a_SlotNum, int a_AddToCount)
 {
 	int GridSlotNum = 0;
 	cItemGrid * Grid = GetGridForSlotNum(a_SlotNum, GridSlotNum);
-	if (Grid == NULL)
+	if (Grid == nullptr)
 	{
 		LOGWARNING("%s: invalid slot number, expected 0 .. %d, got %d; ignoring", __FUNCTION__, invNumSlots, a_SlotNum);
 		return -1;
@@ -398,7 +398,7 @@ bool cInventory::DamageItem(int a_SlotNum, short a_Amount)
 	
 	int GridSlotNum = 0;
 	cItemGrid * Grid = GetGridForSlotNum(a_SlotNum, GridSlotNum);
-	if (Grid == NULL)
+	if (Grid == nullptr)
 	{
 		LOGWARNING("%s(%d, %d): requesting an invalid grid, ignoring.", __FUNCTION__, a_SlotNum, a_Amount);
 		return false;
@@ -640,7 +640,7 @@ bool cInventory::LoadFromJson(Json::Value & a_Value)
 		
 		int GridSlotNum = 0;
 		cItemGrid * Grid = GetGridForSlotNum(SlotIdx - 5, GridSlotNum);
-		ASSERT(Grid != NULL);
+		ASSERT(Grid != nullptr);
 		Grid->SetSlot(GridSlotNum, Item);
 	}  // for itr - a_Value[]
 	return true;
@@ -708,7 +708,7 @@ void cInventory::OnSlotChanged(cItemGrid * a_ItemGrid, int a_SlotNum)
 	
 	// Armor update needs broadcast to other players:
 	cWorld * World = m_Owner.GetWorld();
-	if ((a_ItemGrid == &m_ArmorSlots) && (World != NULL))
+	if ((a_ItemGrid == &m_ArmorSlots) && (World != nullptr))
 	{
 		World->BroadcastEntityEquipment(
 			m_Owner, ArmorSlotNumToEntityEquipmentID(a_SlotNum),
diff --git a/src/Inventory.h b/src/Inventory.h
index 5628fb0da..4e76bc0d3 100644
--- a/src/Inventory.h
+++ b/src/Inventory.h
@@ -179,10 +179,10 @@ protected:
 
 	cPlayer & m_Owner;
 	
-	/** Returns the ItemGrid and the (grid-local) slot number for a (global) slot number; return NULL for invalid SlotNum */
+	/** Returns the ItemGrid and the (grid-local) slot number for a (global) slot number; return nullptr for invalid SlotNum */
 	const cItemGrid * GetGridForSlotNum(int a_SlotNum, int & a_GridSlotNum) const;
 	
-	/** Returns the ItemGrid and the (grid-local) slot number for a (global) slot number; return NULL for invalid SlotNum */
+	/** Returns the ItemGrid and the (grid-local) slot number for a (global) slot number; return nullptr for invalid SlotNum */
 	cItemGrid * GetGridForSlotNum(int a_SlotNum, int & a_GridSlotNum);
 	
 	// cItemGrid::cListener override:
diff --git a/src/Item.cpp b/src/Item.cpp
index ebdf99ca5..36c444328 100644
--- a/src/Item.cpp
+++ b/src/Item.cpp
@@ -391,7 +391,7 @@ cItem * cItems::Get(int a_Idx)
 	if ((a_Idx < 0) || (a_Idx >= (int)size()))
 	{
 		LOGWARNING("cItems: Attempt to get an out-of-bounds item at index %d; there are currently " SIZE_T_FMT " items. Returning a nil.", a_Idx, size());
-		return NULL;
+		return nullptr;
 	}
 	return &at(a_Idx);
 }
diff --git a/src/ItemGrid.cpp b/src/ItemGrid.cpp
index 1977216d8..55fb36a17 100644
--- a/src/ItemGrid.cpp
+++ b/src/ItemGrid.cpp
@@ -28,7 +28,7 @@ cItemGrid::cItemGrid(int a_Width, int a_Height) :
 cItemGrid::~cItemGrid()
 {
 	delete[] m_Slots;
-	m_Slots = NULL;
+	m_Slots = nullptr;
 }
 
 
diff --git a/src/Items/ItemBow.h b/src/Items/ItemBow.h
index f29cc5d59..cf2fe9ad2 100644
--- a/src/Items/ItemBow.h
+++ b/src/Items/ItemBow.h
@@ -29,7 +29,7 @@ public:
 	
 	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
-		ASSERT(a_Player != NULL);
+		ASSERT(a_Player != nullptr);
 		
 		// Check if the player has an arrow in the inventory, or is in Creative:
 		if (!(a_Player->IsGameModeCreative() || a_Player->GetInventory().HasItems(cItem(E_ITEM_ARROW))))
@@ -45,7 +45,7 @@ public:
 	virtual void OnItemShoot(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
 	{
 		// Actual shot - produce the arrow with speed based on the ticks that the bow was charged
-		ASSERT(a_Player != NULL);
+		ASSERT(a_Player != nullptr);
 
 		int BowCharge = a_Player->FinishChargingBow();
 		double Force = (double)BowCharge / 20.0;
@@ -65,14 +65,14 @@ public:
 
 		// Create the arrow entity:
 		cArrowEntity * Arrow = new cArrowEntity(*a_Player, Force * 2);
-		if (Arrow == NULL)
+		if (Arrow == nullptr)
 		{
 			return;
 		}
 		if (!Arrow->Initialize(*a_Player->GetWorld()))
 		{
 			delete Arrow;
-			Arrow = NULL;
+			Arrow = nullptr;
 			return;
 		}
 		a_Player->GetWorld()->BroadcastSoundEffect("random.bow", a_Player->GetPosX(), a_Player->GetPosY(), a_Player->GetPosZ(), 0.5, (float)Force);
diff --git a/src/Items/ItemEmptyMap.h b/src/Items/ItemEmptyMap.h
index 953673382..9238d771b 100644
--- a/src/Items/ItemEmptyMap.h
+++ b/src/Items/ItemEmptyMap.h
@@ -50,7 +50,7 @@ public:
 			return true;
 		}
 
-		if (NewMap == NULL)
+		if (NewMap == nullptr)
 		{
 			return true;
 		}
diff --git a/src/Items/ItemHandler.cpp b/src/Items/ItemHandler.cpp
index 912dde022..d1588e9d8 100644
--- a/src/Items/ItemHandler.cpp
+++ b/src/Items/ItemHandler.cpp
@@ -83,7 +83,7 @@ cItemHandler * cItemHandler::GetItemHandler(int a_ItemType)
 		memset(m_ItemHandler, 0, sizeof(m_ItemHandler));
 		m_HandlerInitialized = true;
 	}
-	if (m_ItemHandler[a_ItemType] == NULL)
+	if (m_ItemHandler[a_ItemType] == nullptr)
 	{
 		m_ItemHandler[a_ItemType] = CreateItemHandler(a_ItemType);
 	}
@@ -278,7 +278,7 @@ void cItemHandler::Deinit()
 	for (int i = 0; i < 2267; i++)
 	{
 		delete m_ItemHandler[i];
-		m_ItemHandler[i] = NULL;
+		m_ItemHandler[i] = nullptr;
 	}
 	memset(m_ItemHandler, 0, sizeof(m_ItemHandler));  // Don't leave any dangling pointers around, just in case
 	m_HandlerInitialized = false;
diff --git a/src/Items/ItemItemFrame.h b/src/Items/ItemItemFrame.h
index 87e20ecf0..5d22c1cb8 100644
--- a/src/Items/ItemItemFrame.h
+++ b/src/Items/ItemItemFrame.h
@@ -37,7 +37,7 @@ public:
 			if (!ItemFrame->Initialize(*a_World))
 			{
 				delete ItemFrame;
-				ItemFrame = NULL;
+				ItemFrame = nullptr;
 				return false;
 			}
 
diff --git a/src/Items/ItemMap.h b/src/Items/ItemMap.h
index 056fe0fe7..2dbbb3dc0 100644
--- a/src/Items/ItemMap.h
+++ b/src/Items/ItemMap.h
@@ -31,7 +31,7 @@ public:
 	{
 		cMap * Map = a_World->GetMapManager().GetMapData((unsigned)a_Item.m_ItemDamage);
 
-		if (Map == NULL)
+		if (Map == nullptr)
 		{
 			return;
 		}
diff --git a/src/Items/ItemMinecart.h b/src/Items/ItemMinecart.h
index 63038de51..ed0a4711c 100644
--- a/src/Items/ItemMinecart.h
+++ b/src/Items/ItemMinecart.h
@@ -56,7 +56,7 @@ public:
 		double x = (double)a_BlockX + 0.5;
 		double y = (double)a_BlockY + 0.5;
 		double z = (double)a_BlockZ + 0.5;
-		cMinecart * Minecart = NULL;
+		cMinecart * Minecart = nullptr;
 		switch (m_ItemType)
 		{
 			case E_ITEM_MINECART:             Minecart = new cRideableMinecart     (x, y, z, cItem(), 1); break;
diff --git a/src/LeakFinder.h b/src/LeakFinder.h
index e63b9ec5d..ceaa53782 100644
--- a/src/LeakFinder.h
+++ b/src/LeakFinder.h
@@ -68,7 +68,7 @@ public:
     LeakFinderShowCompleteCallstack = 0x1000
   } LeakFinderOptions;
 
-  LeakFinderOutput(int options = OptionsAll,  LPCSTR szSymPath = NULL);
+  LeakFinderOutput(int options = OptionsAll,  LPCSTR szSymPath = nullptr);
   virtual void OnLeakSearchStart(LPCSTR sszLeakFinderName);
   virtual void OnLeakStartEntry(LPCSTR szKeyName, SIZE_T nDataSize);
 protected:
@@ -110,7 +110,7 @@ class ZZZ_LeakFinder
 public:
   ZZZ_LeakFinder()
   {
-    m_pXml = NULL;
+    m_pXml = nullptr;
 #ifdef XML_LEAK_FINDER
     m_pXml = new LeakFinderXmlOutput();
 #endif
@@ -119,7 +119,7 @@ public:
   ~ZZZ_LeakFinder()
   {
     DeinitLeakFinder(m_pXml);
-    if (m_pXml != NULL) delete m_pXml;
+    if (m_pXml != nullptr) delete m_pXml;
   }
 protected:
   LeakFinderXmlOutput *m_pXml;
@@ -148,7 +148,7 @@ ZZZ_LeakFinder zzz_LeakFinder;
 
 
 
-extern void DumpUsedMemory(LeakFinderOutput * output = NULL);
+extern void DumpUsedMemory(LeakFinderOutput * output = nullptr);
 
 
 
diff --git a/src/LightingThread.cpp b/src/LightingThread.cpp
index 652b03e46..ae5e746e7 100644
--- a/src/LightingThread.cpp
+++ b/src/LightingThread.cpp
@@ -91,7 +91,7 @@ public:
 
 cLightingThread::cLightingThread(void) :
 	super("cLightingThread"),
-	m_World(NULL),
+	m_World(nullptr),
 	m_MaxHeight(0),
 	m_NumSeeds(0)
 {
@@ -112,7 +112,7 @@ cLightingThread::~cLightingThread()
 
 bool cLightingThread::Start(cWorld * a_World)
 {
-	ASSERT(m_World == NULL);  // Not started yet
+	ASSERT(m_World == nullptr);  // Not started yet
 	m_World = a_World;
 	
 	return super::Start();
@@ -151,7 +151,7 @@ void cLightingThread::Stop(void)
 
 void cLightingThread::QueueChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_CallbackAfter)
 {
-	ASSERT(m_World != NULL);  // Did you call Start() properly?
+	ASSERT(m_World != nullptr);  // Did you call Start() properly?
 	
 	cChunkStay * ChunkStay = new cLightingChunkStay(*this, a_ChunkX, a_ChunkZ, a_CallbackAfter);
 	{
@@ -310,7 +310,7 @@ void cLightingThread::LightChunk(cLightingChunkStay & a_Item)
 	
 	m_World->ChunkLighted(a_Item.m_ChunkX, a_Item.m_ChunkZ, BlockLight, SkyLight);
 
-	if (a_Item.m_CallbackAfter != NULL)
+	if (a_Item.m_CallbackAfter != nullptr)
 	{
 		a_Item.m_CallbackAfter->Call(a_Item.m_ChunkX, a_Item.m_ChunkZ);
 	}
diff --git a/src/LightingThread.h b/src/LightingThread.h
index f71d2cf1a..87eb9c6d8 100644
--- a/src/LightingThread.h
+++ b/src/LightingThread.h
@@ -61,7 +61,7 @@ public:
 	void Stop(void);
 	
 	/** Queues the entire chunk for lighting */
-	void QueueChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_CallbackAfter = NULL);
+	void QueueChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_CallbackAfter = nullptr);
 	
 	/** Blocks until the queue is empty or the thread is terminated */
 	void WaitForQueueEmpty(void);
diff --git a/src/LineBlockTracer.cpp b/src/LineBlockTracer.cpp
index 1b42081c2..90f97cd23 100644
--- a/src/LineBlockTracer.cpp
+++ b/src/LineBlockTracer.cpp
@@ -198,7 +198,7 @@ bool cLineBlockTracer::Item(cChunk * a_Chunk)
 	for (;;)
 	{
 		// Report the current block through the callbacks:
-		if (a_Chunk == NULL)
+		if (a_Chunk == nullptr)
 		{
 			m_Callbacks->OnNoChunk();
 			return false;
@@ -228,7 +228,7 @@ bool cLineBlockTracer::Item(cChunk * a_Chunk)
 
 		// Update the current chunk
 		a_Chunk = a_Chunk->GetNeighborChunk(m_CurrentX, m_CurrentZ);
-		if (a_Chunk == NULL)
+		if (a_Chunk == nullptr)
 		{
 			m_Callbacks->OnNoChunk();
 			return false;
diff --git a/src/LinearUpscale.h b/src/LinearUpscale.h
index a49f4bdf9..1b0fbd89a 100644
--- a/src/LinearUpscale.h
+++ b/src/LinearUpscale.h
@@ -95,8 +95,8 @@ template <typename TYPE> void LinearUpscale2DArray(
 	const int MAX_UPSCALE_X = 128;
 	const int MAX_UPSCALE_Y = 128;
 
-	ASSERT(a_Src != NULL);
-	ASSERT(a_Dst != NULL);
+	ASSERT(a_Src != nullptr);
+	ASSERT(a_Dst != nullptr);
 	ASSERT(a_SrcSizeX > 0);
 	ASSERT(a_SrcSizeY > 0);
 	ASSERT(a_UpscaleX > 0);
@@ -166,8 +166,8 @@ template <typename TYPE> void LinearUpscale3DArray(
 	const int MAX_UPSCALE_Y = 128;
 	const int MAX_UPSCALE_Z = 128;
 
-	ASSERT(a_Src != NULL);
-	ASSERT(a_Dst != NULL);
+	ASSERT(a_Src != nullptr);
+	ASSERT(a_Dst != nullptr);
 	ASSERT(a_SrcSizeX > 0);
 	ASSERT(a_SrcSizeY > 0);
 	ASSERT(a_SrcSizeZ > 0);
diff --git a/src/LoggerListeners.cpp b/src/LoggerListeners.cpp
index 77e2aaf67..5c7097956 100644
--- a/src/LoggerListeners.cpp
+++ b/src/LoggerListeners.cpp
@@ -280,7 +280,7 @@ cFileListener::cFileListener(void)
 {
 	cFile::CreateFolder(FILE_IO_PREFIX + AString("logs"));
 	AString FileName;
-	FileName = Printf("%s%sLOG_%d.txt", FILE_IO_PREFIX, "logs/", (int)time(NULL));
+	FileName = Printf("%s%sLOG_%d.txt", FILE_IO_PREFIX, "logs/", (int)time(nullptr));
 	m_File.Open(FileName, cFile::fmAppend);
 }
 
diff --git a/src/Map.cpp b/src/Map.cpp
index c106ccd83..fbde00cf7 100644
--- a/src/Map.cpp
+++ b/src/Map.cpp
@@ -21,7 +21,7 @@ cMapDecorator::cMapDecorator(cMap * a_Map, eType a_Type, int a_X, int a_Z, int a
 	, m_PixelX(a_X)
 	, m_PixelZ(a_Z)
 	, m_Rot(a_Rot)
-	, m_Player(NULL)
+	, m_Player(nullptr)
 {
 }
 
@@ -43,9 +43,9 @@ cMapDecorator::cMapDecorator(cMap * a_Map, cPlayer * a_Player)
 
 void cMapDecorator::Update(void)
 {
-	if (m_Player != NULL)
+	if (m_Player != nullptr)
 	{
-		ASSERT(m_Map != NULL);
+		ASSERT(m_Map != nullptr);
 		unsigned int PixelWidth = m_Map->GetPixelWidth();
 
 		int InsideWidth  = (m_Map->GetWidth()  / 2) - 1;
@@ -221,7 +221,7 @@ bool cMap::UpdatePixel(unsigned int a_X, unsigned int a_Z)
 
 		virtual bool Item(cChunk * a_Chunk) override
 		{
-			if (a_Chunk == NULL)
+			if (a_Chunk == nullptr)
 			{
 				return false;
 			}
@@ -322,7 +322,7 @@ bool cMap::UpdatePixel(unsigned int a_X, unsigned int a_Z)
 		}
 	} CalculatePixelCb(this, RelX, RelZ);
 
-	ASSERT(m_World != NULL);
+	ASSERT(m_World != nullptr);
 	m_World->DoWithChunk(ChunkX, ChunkZ, CalculatePixelCb);
 
 	SetPixel(a_X, a_Z, CalculatePixelCb.GetPixelData());
@@ -349,7 +349,7 @@ void cMap::UpdateDecorators(void)
 void cMap::AddPlayer(cPlayer * a_Player, Int64 a_WorldAge)
 {
 	cClientHandle * Handle = a_Player->GetClientHandle();
-	if (Handle == NULL)
+	if (Handle == nullptr)
 	{
 		return;
 	}
@@ -454,10 +454,10 @@ void cMap::StreamNext(cMapClient & a_Client)
 
 void cMap::UpdateClient(cPlayer * a_Player)
 {
-	ASSERT(a_Player != NULL);
+	ASSERT(a_Player != nullptr);
 	cClientHandle * Handle = a_Player->GetClientHandle();
 
-	if (Handle == NULL)
+	if (Handle == nullptr)
 	{
 		return;
 	}
@@ -498,7 +498,7 @@ void cMap::EraseData(void)
 
 eDimension cMap::GetDimension(void) const
 {
-	ASSERT(m_World != NULL);
+	ASSERT(m_World != nullptr);
 	return m_World->GetDimension();
 }
 
diff --git a/src/MapManager.cpp b/src/MapManager.cpp
index e7df75118..2a3ab192b 100644
--- a/src/MapManager.cpp
+++ b/src/MapManager.cpp
@@ -15,7 +15,7 @@
 cMapManager::cMapManager(cWorld * a_World)
 	: m_World(a_World)
 {
-	ASSERT(m_World != NULL);
+	ASSERT(m_World != nullptr);
 }
 
 
@@ -27,7 +27,7 @@ bool cMapManager::DoWithMap(int a_ID, cMapCallback & a_Callback)
 	cCSLock Lock(m_CS);
 	cMap * Map = GetMapData(a_ID);
 
-	if (Map == NULL)
+	if (Map == nullptr)
 	{
 		return false;
 	}
@@ -68,7 +68,7 @@ cMap * cMapManager::GetMapData(unsigned int a_ID)
 	}
 	else
 	{
-		return NULL;
+		return nullptr;
 	}
 }
 
@@ -83,7 +83,7 @@ cMap * cMapManager::CreateMap(int a_CenterX, int a_CenterY, int a_Scale)
 	if (m_MapData.size() >= 65536)
 	{
 		LOGWARN("Could not craft map - Too many maps in use");
-		return NULL;
+		return nullptr;
 	}
 
 	cMap Map((unsigned)m_MapData.size(), a_CenterX, a_CenterY, m_World, a_Scale);
diff --git a/src/MapManager.h b/src/MapManager.h
index a40ec2630..2cc6a7bce 100644
--- a/src/MapManager.h
+++ b/src/MapManager.h
@@ -31,12 +31,12 @@ public:
 
 	cMapManager(cWorld * a_World);
 
-	/** Returns the map with the specified ID, NULL if out of range.
+	/** Returns the map with the specified ID, nullptr if out of range.
 	WARNING: The returned map object is not thread safe.
 	*/
 	cMap * GetMapData(unsigned int a_ID);
 
-	/** Creates a new map. Returns NULL on error */
+	/** Creates a new map. Returns nullptr on error */
 	cMap * CreateMap(int a_CenterX, int a_CenterY, int a_Scale = 3);
 
 	/** Calls the callback for the map with the specified ID.
diff --git a/src/MobSpawner.cpp b/src/MobSpawner.cpp
index ea3fe8c72..e461fae4c 100644
--- a/src/MobSpawner.cpp
+++ b/src/MobSpawner.cpp
@@ -301,7 +301,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 
 cMonster* cMobSpawner::TryToSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, EMCSBiome a_Biome, int& a_MaxPackSize)
 {
-	cMonster* toReturn = NULL;
+	cMonster* toReturn = nullptr;
 	if (m_NewPack)
 	{
 		m_MobType = ChooseMobType(a_Biome);
diff --git a/src/Mobs/AggressiveMonster.cpp b/src/Mobs/AggressiveMonster.cpp
index be2f71f7a..41ef26e2a 100644
--- a/src/Mobs/AggressiveMonster.cpp
+++ b/src/Mobs/AggressiveMonster.cpp
@@ -26,7 +26,7 @@ void cAggressiveMonster::InStateChasing(float a_Dt)
 {
 	super::InStateChasing(a_Dt);
 
-	if (m_Target != NULL)
+	if (m_Target != nullptr)
 	{
 		if (m_Target->IsPlayer())
 		{
@@ -74,7 +74,7 @@ void cAggressiveMonster::Tick(float a_Dt, cChunk & a_Chunk)
 		CheckEventSeePlayer();
 	}
 
-	if (m_Target == NULL)
+	if (m_Target == nullptr)
 		return;
 
 	cTracer LineOfSight(GetWorld());
@@ -95,7 +95,7 @@ void cAggressiveMonster::Attack(float a_Dt)
 {
 	m_AttackInterval += a_Dt * m_AttackRate;
 
-	if ((m_Target == NULL) || (m_AttackInterval < 3.0))
+	if ((m_Target == nullptr) || (m_AttackInterval < 3.0))
 	{
 		return;
 	}
diff --git a/src/Mobs/Blaze.cpp b/src/Mobs/Blaze.cpp
index b4104d530..16869c79d 100644
--- a/src/Mobs/Blaze.cpp
+++ b/src/Mobs/Blaze.cpp
@@ -19,7 +19,7 @@ cBlaze::cBlaze(void) :
 
 void cBlaze::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	if ((a_Killer != NULL) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf")))
+	if ((a_Killer != nullptr) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf")))
 	{
 		int LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 		AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_BLAZE_ROD);
@@ -34,20 +34,20 @@ void cBlaze::Attack(float a_Dt)
 {
 	m_AttackInterval += a_Dt * m_AttackRate;
 
-	if (m_Target != NULL && m_AttackInterval > 3.0)
+	if (m_Target != nullptr && m_AttackInterval > 3.0)
 	{
 		// Setting this higher gives us more wiggle room for attackrate
 		Vector3d Speed = GetLookVector() * 20;
 		Speed.y = Speed.y + 1;
 		cFireChargeEntity * FireCharge = new cFireChargeEntity(this, GetPosX(), GetPosY() + 1, GetPosZ(), Speed);
-		if (FireCharge == NULL)
+		if (FireCharge == nullptr)
 		{
 			return;
 		}
 		if (!FireCharge->Initialize(*m_World))
 		{
 			delete FireCharge;
-			FireCharge = NULL;
+			FireCharge = nullptr;
 			return;
 		}
 		m_World->BroadcastSpawnEntity(*FireCharge);
diff --git a/src/Mobs/Blaze.h b/src/Mobs/Blaze.h
index f283b1070..e2a4ad9f1 100644
--- a/src/Mobs/Blaze.h
+++ b/src/Mobs/Blaze.h
@@ -17,6 +17,6 @@ public:
 
 	CLASS_PROTODEF(cBlaze)
 	
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void Attack(float a_Dt) override;
 } ;
diff --git a/src/Mobs/CaveSpider.cpp b/src/Mobs/CaveSpider.cpp
index 118a6e93b..045b47e73 100644
--- a/src/Mobs/CaveSpider.cpp
+++ b/src/Mobs/CaveSpider.cpp
@@ -45,12 +45,12 @@ void cCaveSpider::Attack(float a_Dt)
 void cCaveSpider::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
 	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_STRING);
-	if ((a_Killer != NULL) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf")))
+	if ((a_Killer != nullptr) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf")))
 	{
 		AddRandomUncommonDropItem(a_Drops, 33.0f, E_ITEM_SPIDER_EYE);
 	}
diff --git a/src/Mobs/CaveSpider.h b/src/Mobs/CaveSpider.h
index f9ed10e1b..494ba1360 100644
--- a/src/Mobs/CaveSpider.h
+++ b/src/Mobs/CaveSpider.h
@@ -18,7 +18,7 @@ public:
 
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 	virtual void Attack(float a_Dt) override;
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 } ;
 
 
diff --git a/src/Mobs/Chicken.cpp b/src/Mobs/Chicken.cpp
index f7e44238f..634867cfa 100644
--- a/src/Mobs/Chicken.cpp
+++ b/src/Mobs/Chicken.cpp
@@ -49,7 +49,7 @@ void cChicken::Tick(float a_Dt, cChunk & a_Chunk)
 void cChicken::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
diff --git a/src/Mobs/Chicken.h b/src/Mobs/Chicken.h
index b1a50b61c..07b921884 100644
--- a/src/Mobs/Chicken.h
+++ b/src/Mobs/Chicken.h
@@ -16,7 +16,7 @@ public:
 
 	CLASS_PROTODEF(cChicken)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 
 	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_SEEDS); }
diff --git a/src/Mobs/Cow.cpp b/src/Mobs/Cow.cpp
index 9914df6b5..7dc6f3f37 100644
--- a/src/Mobs/Cow.cpp
+++ b/src/Mobs/Cow.cpp
@@ -22,7 +22,7 @@ cCow::cCow(void) :
 void cCow::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
diff --git a/src/Mobs/Cow.h b/src/Mobs/Cow.h
index 8814b7e09..ee1a4fafe 100644
--- a/src/Mobs/Cow.h
+++ b/src/Mobs/Cow.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cCow)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
 
 	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_WHEAT); }
diff --git a/src/Mobs/Creeper.cpp b/src/Mobs/Creeper.cpp
index 02718edf8..a073224cf 100644
--- a/src/Mobs/Creeper.cpp
+++ b/src/Mobs/Creeper.cpp
@@ -61,13 +61,13 @@ void cCreeper::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 	}
 
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
 	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GUNPOWDER);
 
-	if ((a_Killer != NULL) && a_Killer->IsProjectile() && (((cProjectileEntity *)a_Killer)->GetCreatorUniqueID() >= 0))
+	if ((a_Killer != nullptr) && a_Killer->IsProjectile() && (((cProjectileEntity *)a_Killer)->GetCreatorUniqueID() >= 0))
 	{
 		class cProjectileCreatorCallback : public cEntityCallback
 		{
diff --git a/src/Mobs/Creeper.h b/src/Mobs/Creeper.h
index 747daca09..bf3272e22 100644
--- a/src/Mobs/Creeper.h
+++ b/src/Mobs/Creeper.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cCreeper)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual bool DoTakeDamage(TakeDamageInfo & a_TDI) override;
 	virtual void Attack(float a_Dt) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
diff --git a/src/Mobs/EnderDragon.h b/src/Mobs/EnderDragon.h
index 1d4cd657c..e4ca9dcf9 100644
--- a/src/Mobs/EnderDragon.h
+++ b/src/Mobs/EnderDragon.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cEnderDragon)
 	
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 } ;
 
 
diff --git a/src/Mobs/Enderman.cpp b/src/Mobs/Enderman.cpp
index 567714382..56ea10245 100644
--- a/src/Mobs/Enderman.cpp
+++ b/src/Mobs/Enderman.cpp
@@ -15,7 +15,7 @@ class cPlayerLookCheck :
 {
 public:
 	cPlayerLookCheck(Vector3d a_EndermanPos, int a_SightDistance) :
-		m_Player(NULL),
+		m_Player(nullptr),
 		m_EndermanPos(a_EndermanPos),
 		m_SightDistance(a_SightDistance)
 	{
@@ -92,7 +92,7 @@ cEnderman::cEnderman(void) :
 void cEnderman::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
@@ -104,7 +104,7 @@ void cEnderman::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 
 void cEnderman::CheckEventSeePlayer()
 {
-	if (m_Target != NULL)
+	if (m_Target != nullptr)
 	{
 		return;
 	}
@@ -115,7 +115,7 @@ void cEnderman::CheckEventSeePlayer()
 		return;
 	}
 	
-	ASSERT(Callback.GetPlayer() != NULL);
+	ASSERT(Callback.GetPlayer() != nullptr);
 
 	if (!CheckLight())
 	{
@@ -196,7 +196,7 @@ void cEnderman::Tick(float a_Dt, cChunk & a_Chunk)
 	if (IsSwimming())
 	{
 		EventLosePlayer();
-		TakeDamage(dtDrowning, NULL, 1, 0);
+		TakeDamage(dtDrowning, nullptr, 1, 0);
 		// TODO teleport to a safe location
 	}
 
diff --git a/src/Mobs/Enderman.h b/src/Mobs/Enderman.h
index 947c32b96..28bbceb84 100644
--- a/src/Mobs/Enderman.h
+++ b/src/Mobs/Enderman.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cEnderman)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void CheckEventSeePlayer(void) override;
 	virtual void CheckEventLostPlayer(void) override;
 	virtual void EventLosePlayer(void) override;
diff --git a/src/Mobs/Ghast.cpp b/src/Mobs/Ghast.cpp
index 6aac14779..c65c0d29a 100644
--- a/src/Mobs/Ghast.cpp
+++ b/src/Mobs/Ghast.cpp
@@ -20,7 +20,7 @@ cGhast::cGhast(void) :
 void cGhast::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
@@ -36,20 +36,20 @@ void cGhast::Attack(float a_Dt)
 {
 	m_AttackInterval += a_Dt * m_AttackRate;
 	
-	if (m_Target != NULL && m_AttackInterval > 3.0)
+	if (m_Target != nullptr && m_AttackInterval > 3.0)
 	{
 		// Setting this higher gives us more wiggle room for attackrate
 		Vector3d Speed = GetLookVector() * 20;
 		Speed.y = Speed.y + 1;
 		cGhastFireballEntity * GhastBall = new cGhastFireballEntity(this, GetPosX(), GetPosY() + 1, GetPosZ(), Speed);
-		if (GhastBall == NULL)
+		if (GhastBall == nullptr)
 		{
 			return;
 		}
 		if (!GhastBall->Initialize(*m_World))
 		{
 			delete GhastBall;
-			GhastBall = NULL;
+			GhastBall = nullptr;
 			return;
 		}
 		m_World->BroadcastSpawnEntity(*GhastBall);
diff --git a/src/Mobs/Ghast.h b/src/Mobs/Ghast.h
index 1d4e6b94a..a28940a01 100644
--- a/src/Mobs/Ghast.h
+++ b/src/Mobs/Ghast.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cGhast)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void Attack(float a_Dt) override;
 
 	bool IsCharging(void) const {return false; }
diff --git a/src/Mobs/Giant.h b/src/Mobs/Giant.h
index 7c04c9b4f..8d3060940 100644
--- a/src/Mobs/Giant.h
+++ b/src/Mobs/Giant.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cGiant)
 	
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 } ;
 
 
diff --git a/src/Mobs/Horse.cpp b/src/Mobs/Horse.cpp
index 67a09d4ab..d92f0d023 100644
--- a/src/Mobs/Horse.cpp
+++ b/src/Mobs/Horse.cpp
@@ -49,7 +49,7 @@ void cHorse::Tick(float a_Dt, cChunk & a_Chunk)
 		}
 	}
 
-	if ((m_Attachee != NULL) && (!m_bIsTame))
+	if ((m_Attachee != nullptr) && (!m_bIsTame))
 	{
 		if (m_TameAttemptTimes < m_TimesToTame)
 		{
@@ -113,7 +113,7 @@ void cHorse::OnRightClicked(cPlayer & a_Player)
 	}
 	else
 	{
-		if (m_Attachee != NULL)
+		if (m_Attachee != nullptr)
 		{
 			if (m_Attachee->GetUniqueID() == a_Player.GetUniqueID())
 			{
@@ -141,7 +141,7 @@ void cHorse::OnRightClicked(cPlayer & a_Player)
 void cHorse::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
diff --git a/src/Mobs/Horse.h b/src/Mobs/Horse.h
index 47189b3b0..4c644e512 100644
--- a/src/Mobs/Horse.h
+++ b/src/Mobs/Horse.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cHorse)
 	
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
 
diff --git a/src/Mobs/IronGolem.h b/src/Mobs/IronGolem.h
index c5341ed76..721ca2701 100644
--- a/src/Mobs/IronGolem.h
+++ b/src/Mobs/IronGolem.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cIronGolem)
 	
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 
 	// Iron golems do not drown nor float
 	virtual void HandleAir(void) override {}
diff --git a/src/Mobs/MagmaCube.h b/src/Mobs/MagmaCube.h
index bfe63fa2e..d66ea423a 100644
--- a/src/Mobs/MagmaCube.h
+++ b/src/Mobs/MagmaCube.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cMagmaCube)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	int GetSize(void) const { return m_Size; }
 	
 protected:
diff --git a/src/Mobs/Monster.cpp b/src/Mobs/Monster.cpp
index 34dd08f37..bcdc404c2 100644
--- a/src/Mobs/Monster.cpp
+++ b/src/Mobs/Monster.cpp
@@ -78,7 +78,7 @@ cMonster::cMonster(const AString & a_ConfigName, eMonsterType a_MobType, const A
 	: super(etMonster, a_Width, a_Height)
 	, m_EMState(IDLE)
 	, m_EMPersonality(AGGRESSIVE)
-	, m_Target(NULL)
+	, m_Target(nullptr)
 	, m_bMovingToDestination(false)
 	, m_LastGroundHeight(POSY_TOINT)
 	, m_IdleInterval(0)
@@ -273,8 +273,8 @@ void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
 		return;
 	}
 
-	if ((m_Target != NULL) && m_Target->IsDestroyed())
-		m_Target = NULL;
+	if ((m_Target != nullptr) && m_Target->IsDestroyed())
+		m_Target = nullptr;
 
 	// Burning in daylight
 	HandleDaylightBurning(a_Chunk);
@@ -378,7 +378,7 @@ void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
 void cMonster::SetPitchAndYawFromDestination()
 {
 	Vector3d FinalDestination = m_FinalDestination;
-	if (m_Target != NULL)
+	if (m_Target != nullptr)
 	{
 		if (m_Target->IsPlayer())
 		{
@@ -422,7 +422,7 @@ void cMonster::HandleFalling()
 
 		if (Damage > 0)
 		{
-			TakeDamage(dtFalling, NULL, Damage, Damage, 0);
+			TakeDamage(dtFalling, nullptr, Damage, Damage, 0);
 
 			// Fall particles
 			GetWorld()->BroadcastSoundParticleEffect(2006, POSX_TOINT, POSY_TOINT - 1, POSZ_TOINT, Damage /* Used as particle effect speed modifier */);
@@ -478,7 +478,7 @@ bool cMonster::DoTakeDamage(TakeDamageInfo & a_TDI)
 		m_World->BroadcastSoundEffect(m_SoundHurt, GetPosX(), GetPosY(), GetPosZ(), 1.0f, 0.8f);
 	}
 
-	if (a_TDI.Attacker != NULL)
+	if (a_TDI.Attacker != nullptr)
 	{
 		m_Target = a_TDI.Attacker;
 	}
@@ -555,7 +555,7 @@ void cMonster::KilledBy(TakeDamageInfo & a_TDI)
 			break;
 		}
 	}
-	if ((a_TDI.Attacker != NULL) && (!IsBaby()))
+	if ((a_TDI.Attacker != nullptr) && (!IsBaby()))
 	{
 		m_World->SpawnExperienceOrb(GetPosX(), GetPosY(), GetPosZ(), Reward);
 	}
@@ -592,7 +592,7 @@ void cMonster::CheckEventSeePlayer(void)
 	// TODO: Rewrite this to use cWorld's DoWithPlayers()
 	cPlayer * Closest = m_World->FindClosestPlayer(GetPosition(), (float)m_SightDistance, false);
 
-	if (Closest != NULL)
+	if (Closest != nullptr)
 	{
 		EventSeePlayer(Closest);
 	}
@@ -604,7 +604,7 @@ void cMonster::CheckEventSeePlayer(void)
 
 void cMonster::CheckEventLostPlayer(void)
 {
-	if (m_Target != NULL)
+	if (m_Target != nullptr)
 	{
 		if ((m_Target->GetPosition() - GetPosition()).Length() > m_SightDistance)
 		{
@@ -634,7 +634,7 @@ void cMonster::EventSeePlayer(cEntity * a_SeenPlayer)
 
 void cMonster::EventLosePlayer(void)
 {
-	m_Target = NULL;
+	m_Target = nullptr;
 	m_EMState = IDLE;
 }
 
@@ -696,7 +696,7 @@ void cMonster::InStateEscaping(float a_Dt)
 {
 	UNUSED(a_Dt);
 	
-	if (m_Target != NULL)
+	if (m_Target != nullptr)
 	{
 		Vector3d newloc = GetPosition();
 		newloc.x = (m_Target->GetPosition().x < newloc.x)? (newloc.x + m_SightDistance): (newloc.x - m_SightDistance);
@@ -723,7 +723,7 @@ void cMonster::SetCustomName(const AString & a_CustomName)
 		m_CustomName = a_CustomName.substr(0, 64);
 	}
 
-	if (m_World != NULL)
+	if (m_World != nullptr)
 	{
 		m_World->BroadcastEntityMetadata(*this);
 	}
@@ -736,7 +736,7 @@ void cMonster::SetCustomName(const AString & a_CustomName)
 void cMonster::SetCustomNameAlwaysVisible(bool a_CustomNameAlwaysVisible)
 {
 	m_CustomNameAlwaysVisible = a_CustomNameAlwaysVisible;
-	if (m_World != NULL)
+	if (m_World != nullptr)
 	{
 		m_World->BroadcastEntityMetadata(*this);
 	}
@@ -892,7 +892,7 @@ int cMonster::GetSpawnDelay(cMonster::eFamily a_MobFamily)
 cMonster * cMonster::NewMonsterFromType(eMonsterType a_MobType)
 {
 	cFastRandom Random;
-	cMonster * toReturn = NULL;
+	cMonster * toReturn = nullptr;
 
 	// Create the mob entity
 	switch (a_MobType)
diff --git a/src/Mobs/Mooshroom.cpp b/src/Mobs/Mooshroom.cpp
index 99958720f..ec533cfca 100644
--- a/src/Mobs/Mooshroom.cpp
+++ b/src/Mobs/Mooshroom.cpp
@@ -25,7 +25,7 @@ cMooshroom::cMooshroom(void) :
 void cMooshroom::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
diff --git a/src/Mobs/Mooshroom.h b/src/Mobs/Mooshroom.h
index fb002c2bf..754725c92 100644
--- a/src/Mobs/Mooshroom.h
+++ b/src/Mobs/Mooshroom.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cMooshroom)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
 
 	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_WHEAT); }
diff --git a/src/Mobs/PassiveAggressiveMonster.cpp b/src/Mobs/PassiveAggressiveMonster.cpp
index e0cc2fd21..cb8650cb9 100644
--- a/src/Mobs/PassiveAggressiveMonster.cpp
+++ b/src/Mobs/PassiveAggressiveMonster.cpp
@@ -26,7 +26,7 @@ bool cPassiveAggressiveMonster::DoTakeDamage(TakeDamageInfo & a_TDI)
 		return false;
 	}
 	
-	if ((m_Target != NULL) && (m_Target->IsPlayer()))
+	if ((m_Target != nullptr) && (m_Target->IsPlayer()))
 	{
 		if (!((cPlayer *)m_Target)->IsGameModeCreative())
 		{
diff --git a/src/Mobs/PassiveMonster.cpp b/src/Mobs/PassiveMonster.cpp
index be3043e3d..1048616d0 100644
--- a/src/Mobs/PassiveMonster.cpp
+++ b/src/Mobs/PassiveMonster.cpp
@@ -24,7 +24,7 @@ bool cPassiveMonster::DoTakeDamage(TakeDamageInfo & a_TDI)
 	{
 		return false;
 	}
-	if ((a_TDI.Attacker != this) && (a_TDI.Attacker != NULL))
+	if ((a_TDI.Attacker != this) && (a_TDI.Attacker != nullptr))
 	{
 		m_EMState = ESCAPING;
 	}
@@ -49,7 +49,7 @@ void cPassiveMonster::Tick(float a_Dt, cChunk & a_Chunk)
 		return;
 	}
 	cPlayer * a_Closest_Player = m_World->FindClosestPlayer(GetPosition(), (float)m_SightDistance);
-	if (a_Closest_Player != NULL)
+	if (a_Closest_Player != nullptr)
 	{
 		if (a_Closest_Player->GetEquippedItem().IsEqual(FollowedItem))
 		{
diff --git a/src/Mobs/Pig.cpp b/src/Mobs/Pig.cpp
index 1f77cf613..55a4412ca 100644
--- a/src/Mobs/Pig.cpp
+++ b/src/Mobs/Pig.cpp
@@ -22,7 +22,7 @@ cPig::cPig(void) :
 void cPig::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
@@ -41,7 +41,7 @@ void cPig::OnRightClicked(cPlayer & a_Player)
 {
 	if (m_bIsSaddled)
 	{
-		if (m_Attachee != NULL)
+		if (m_Attachee != nullptr)
 		{
 			if (m_Attachee->GetUniqueID() == a_Player.GetUniqueID())
 			{
@@ -85,7 +85,7 @@ void cPig::Tick(float a_Dt, cChunk & a_Chunk)
 	super::Tick(a_Dt, a_Chunk);
 
 	// If the attachee player is holding a carrot-on-stick, let them drive this pig:
-	if (m_bIsSaddled && (m_Attachee != NULL))
+	if (m_bIsSaddled && (m_Attachee != nullptr))
 	{
 		if (m_Attachee->IsPlayer() && (m_Attachee->GetEquippedWeapon().m_ItemType == E_ITEM_CARROT_ON_STICK))
 		{
diff --git a/src/Mobs/Pig.h b/src/Mobs/Pig.h
index 534a0ca6f..953850b3a 100644
--- a/src/Mobs/Pig.h
+++ b/src/Mobs/Pig.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cPig)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 
diff --git a/src/Mobs/Sheep.cpp b/src/Mobs/Sheep.cpp
index cbb33cb90..c46404391 100644
--- a/src/Mobs/Sheep.cpp
+++ b/src/Mobs/Sheep.cpp
@@ -41,7 +41,7 @@ void cSheep::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 	}
 
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
diff --git a/src/Mobs/Sheep.h b/src/Mobs/Sheep.h
index 28e1c7254..16d5fddd3 100644
--- a/src/Mobs/Sheep.h
+++ b/src/Mobs/Sheep.h
@@ -22,7 +22,7 @@ public:
 
 	CLASS_PROTODEF(cSheep)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 
diff --git a/src/Mobs/Skeleton.cpp b/src/Mobs/Skeleton.cpp
index cd707f4bb..f17bc307c 100644
--- a/src/Mobs/Skeleton.cpp
+++ b/src/Mobs/Skeleton.cpp
@@ -23,7 +23,7 @@ cSkeleton::cSkeleton(bool IsWither) :
 void cSkeleton::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
@@ -71,20 +71,20 @@ void cSkeleton::Attack(float a_Dt)
 {
 	m_AttackInterval += a_Dt * m_AttackRate;
 
-	if (m_Target != NULL && m_AttackInterval > 3.0)
+	if (m_Target != nullptr && m_AttackInterval > 3.0)
 	{
 		// Setting this higher gives us more wiggle room for attackrate
 		Vector3d Speed = GetLookVector() * 20;
 		Speed.y = Speed.y + 1;
 		cArrowEntity * Arrow = new cArrowEntity(this, GetPosX(), GetPosY() + 1, GetPosZ(), Speed);
-		if (Arrow == NULL)
+		if (Arrow == nullptr)
 		{
 			return;
 		}
 		if (!Arrow->Initialize(*m_World))
 		{
 			delete Arrow;
-			Arrow = NULL;
+			Arrow = nullptr;
 			return;
 		}
 		m_World->BroadcastSpawnEntity(*Arrow);
diff --git a/src/Mobs/Skeleton.h b/src/Mobs/Skeleton.h
index 577588b32..cd1c6c3f0 100644
--- a/src/Mobs/Skeleton.h
+++ b/src/Mobs/Skeleton.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cSkeleton)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void MoveToPosition(const Vector3d & a_Position) override;
 	virtual void Attack(float a_Dt) override;
 	virtual void SpawnOn(cClientHandle & a_ClientHandle) override;
diff --git a/src/Mobs/Slime.cpp b/src/Mobs/Slime.cpp
index b709ec664..1c68c5189 100644
--- a/src/Mobs/Slime.cpp
+++ b/src/Mobs/Slime.cpp
@@ -30,7 +30,7 @@ cSlime::cSlime(int a_Size) :
 void cSlime::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
diff --git a/src/Mobs/Slime.h b/src/Mobs/Slime.h
index f0b800f94..a177a279c 100644
--- a/src/Mobs/Slime.h
+++ b/src/Mobs/Slime.h
@@ -19,7 +19,7 @@ public:
 	CLASS_PROTODEF(cSlime)
 
 	// cAggressiveMonster overrides:
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void Attack(float a_Dt) override;
 	virtual void KilledBy(TakeDamageInfo & a_TDI) override;
 
diff --git a/src/Mobs/SnowGolem.h b/src/Mobs/SnowGolem.h
index aba89e52d..f036b1867 100644
--- a/src/Mobs/SnowGolem.h
+++ b/src/Mobs/SnowGolem.h
@@ -18,7 +18,7 @@ public:
 	CLASS_PROTODEF(cSnowGolem)
 	
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 } ;
 
 
diff --git a/src/Mobs/Spider.cpp b/src/Mobs/Spider.cpp
index 8b978ff6b..deb263c41 100644
--- a/src/Mobs/Spider.cpp
+++ b/src/Mobs/Spider.cpp
@@ -19,12 +19,12 @@ cSpider::cSpider(void) :
 void cSpider::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
 	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_STRING);
-	if ((a_Killer != NULL) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf")))
+	if ((a_Killer != nullptr) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf")))
 	{
 		AddRandomUncommonDropItem(a_Drops, 33.0f, E_ITEM_SPIDER_EYE);
 	}
diff --git a/src/Mobs/Spider.h b/src/Mobs/Spider.h
index 813d2e266..24134c00f 100644
--- a/src/Mobs/Spider.h
+++ b/src/Mobs/Spider.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cSpider)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 } ;
 
 
diff --git a/src/Mobs/Squid.cpp b/src/Mobs/Squid.cpp
index bd0e141a0..59ee963ae 100644
--- a/src/Mobs/Squid.cpp
+++ b/src/Mobs/Squid.cpp
@@ -22,7 +22,7 @@ void cSquid::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	// Drops 0-3 Ink Sacs
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
diff --git a/src/Mobs/Squid.h b/src/Mobs/Squid.h
index b57340427..a46d738c6 100644
--- a/src/Mobs/Squid.h
+++ b/src/Mobs/Squid.h
@@ -19,7 +19,7 @@ public:
 
 	CLASS_PROTODEF(cSquid)
 	
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 
 	// Squids do not drown (or float)
 	virtual void HandleAir(void) override {}
diff --git a/src/Mobs/Villager.cpp b/src/Mobs/Villager.cpp
index 0efd5501e..5c9999a59 100644
--- a/src/Mobs/Villager.cpp
+++ b/src/Mobs/Villager.cpp
@@ -30,7 +30,7 @@ bool cVillager::DoTakeDamage(TakeDamageInfo & a_TDI)
 		return false;
 	}
 
-	if ((a_TDI.Attacker != NULL) && a_TDI.Attacker->IsPlayer())
+	if ((a_TDI.Attacker != nullptr) && a_TDI.Attacker->IsPlayer())
 	{
 		if (m_World->GetTickRandomNumber(5) == 3)
 		{
diff --git a/src/Mobs/Witch.cpp b/src/Mobs/Witch.cpp
index 947be0011..a3cadbaa0 100644
--- a/src/Mobs/Witch.cpp
+++ b/src/Mobs/Witch.cpp
@@ -20,7 +20,7 @@ cWitch::cWitch(void) :
 void cWitch::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
diff --git a/src/Mobs/Witch.h b/src/Mobs/Witch.h
index 85d3e1447..8230e1f98 100644
--- a/src/Mobs/Witch.h
+++ b/src/Mobs/Witch.h
@@ -17,7 +17,7 @@ public:
 
 	CLASS_PROTODEF(cWitch)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 
 	bool IsAngry(void) const {return ((m_EMState == ATTACKING) || (m_EMState == CHASING)); }
 } ;
diff --git a/src/Mobs/Wither.h b/src/Mobs/Wither.h
index 2403823ed..a20fed3d3 100644
--- a/src/Mobs/Wither.h
+++ b/src/Mobs/Wither.h
@@ -26,7 +26,7 @@ public:
 	
 	// cEntity overrides
 	virtual bool Initialize(cWorld & a_World) override;
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual bool DoTakeDamage(TakeDamageInfo & a_TDI) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 	virtual void KilledBy(TakeDamageInfo & a_TDI) override;
diff --git a/src/Mobs/Wolf.cpp b/src/Mobs/Wolf.cpp
index 4fe1ff1d6..4711d5a7a 100644
--- a/src/Mobs/Wolf.cpp
+++ b/src/Mobs/Wolf.cpp
@@ -47,7 +47,7 @@ void cWolf::Attack(float a_Dt)
 {
 	UNUSED(a_Dt);
 
-	if ((m_Target != NULL) && (m_Target->IsPlayer()))
+	if ((m_Target != nullptr) && (m_Target->IsPlayer()))
 	{
 		if (((cPlayer *)m_Target)->GetName() != m_OwnerName)
 		{
@@ -157,7 +157,7 @@ void cWolf::Tick(float a_Dt, cChunk & a_Chunk)
 	}
 
 	cPlayer * a_Closest_Player = m_World->FindClosestPlayer(GetPosition(), (float)m_SightDistance);
-	if (a_Closest_Player != NULL)
+	if (a_Closest_Player != nullptr)
 	{
 		switch (a_Closest_Player->GetEquippedItem().m_ItemType)
 		{
diff --git a/src/Mobs/Zombie.cpp b/src/Mobs/Zombie.cpp
index 30225c32d..63042e252 100644
--- a/src/Mobs/Zombie.cpp
+++ b/src/Mobs/Zombie.cpp
@@ -24,7 +24,7 @@ cZombie::cZombie(bool a_IsVillagerZombie) :
 void cZombie::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
diff --git a/src/Mobs/Zombie.h b/src/Mobs/Zombie.h
index 118b6e6e7..809c2a6fe 100644
--- a/src/Mobs/Zombie.h
+++ b/src/Mobs/Zombie.h
@@ -16,7 +16,7 @@ public:
 
 	CLASS_PROTODEF(cZombie)
 	
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void MoveToPosition(const Vector3d & a_Position) override;
 
 	virtual bool IsUndead(void) override { return true; }
diff --git a/src/Mobs/ZombiePigman.cpp b/src/Mobs/ZombiePigman.cpp
index 05350f877..8b415b0af 100644
--- a/src/Mobs/ZombiePigman.cpp
+++ b/src/Mobs/ZombiePigman.cpp
@@ -19,7 +19,7 @@ cZombiePigman::cZombiePigman(void) :
 void cZombiePigman::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	int LootingLevel = 0;
-	if (a_Killer != NULL)
+	if (a_Killer != nullptr)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
@@ -41,7 +41,7 @@ void cZombiePigman::KilledBy(TakeDamageInfo & a_TDI)
 {
 	super::KilledBy(a_TDI);
 
-	if ((a_TDI.Attacker != NULL) && (a_TDI.Attacker->IsPlayer()))
+	if ((a_TDI.Attacker != nullptr) && (a_TDI.Attacker->IsPlayer()))
 	{
 		// TODO: Anger all nearby zombie pigmen
 		// TODO: In vanilla, if one player angers ZPs, do they attack any nearby player, or only that one attacker?
diff --git a/src/Mobs/ZombiePigman.h b/src/Mobs/ZombiePigman.h
index bae0115eb..d8b886ca4 100644
--- a/src/Mobs/ZombiePigman.h
+++ b/src/Mobs/ZombiePigman.h
@@ -16,7 +16,7 @@ public:
 
 	CLASS_PROTODEF(cZombiePigman)
 
-	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override;
 	virtual void KilledBy(TakeDamageInfo & a_TDI) override;
 	
 	virtual bool IsUndead(void) override { return true; }
diff --git a/src/MonsterConfig.cpp b/src/MonsterConfig.cpp
index f5e078213..a15e413ba 100644
--- a/src/MonsterConfig.cpp
+++ b/src/MonsterConfig.cpp
@@ -47,7 +47,7 @@ cMonsterConfig::cMonsterConfig(void)
 cMonsterConfig::~cMonsterConfig()
 {
 	delete m_pState;
-	m_pState = NULL;
+	m_pState = nullptr;
 }
 
 
diff --git a/src/Noise.cpp b/src/Noise.cpp
index 71e801f30..8fcfe2920 100644
--- a/src/Noise.cpp
+++ b/src/Noise.cpp
@@ -845,7 +845,7 @@ void cPerlinNoise::Generate2D(
 		return;
 	}
 	
-	bool ShouldFreeWorkspace = (a_Workspace == NULL);
+	bool ShouldFreeWorkspace = (a_Workspace == nullptr);
 	int ArrayCount = a_SizeX * a_SizeY;
 	if (ShouldFreeWorkspace)
 	{
@@ -886,7 +886,7 @@ void cPerlinNoise::Generate2D(
 	if (ShouldFreeWorkspace)
 	{
 		delete[] a_Workspace;
-		a_Workspace = NULL;
+		a_Workspace = nullptr;
 	}
 }
 
@@ -910,7 +910,7 @@ void cPerlinNoise::Generate3D(
 		return;
 	}
 	
-	bool ShouldFreeWorkspace = (a_Workspace == NULL);
+	bool ShouldFreeWorkspace = (a_Workspace == nullptr);
 	int ArrayCount = a_SizeX * a_SizeY * a_SizeZ;
 	if (ShouldFreeWorkspace)
 	{
@@ -953,7 +953,7 @@ void cPerlinNoise::Generate3D(
 	if (ShouldFreeWorkspace)
 	{
 		delete[] a_Workspace;
-		a_Workspace = NULL;
+		a_Workspace = nullptr;
 	}
 }
 
@@ -1015,7 +1015,7 @@ void cRidgedMultiNoise::Generate2D(
 		return;
 	}
 	
-	bool ShouldFreeWorkspace = (a_Workspace == NULL);
+	bool ShouldFreeWorkspace = (a_Workspace == nullptr);
 	int ArrayCount = a_SizeX * a_SizeY;
 	if (ShouldFreeWorkspace)
 	{
@@ -1056,7 +1056,7 @@ void cRidgedMultiNoise::Generate2D(
 	if (ShouldFreeWorkspace)
 	{
 		delete[] a_Workspace;
-		a_Workspace = NULL;
+		a_Workspace = nullptr;
 	}
 }
 
@@ -1080,7 +1080,7 @@ void cRidgedMultiNoise::Generate3D(
 		return;
 	}
 	
-	bool ShouldFreeWorkspace = (a_Workspace == NULL);
+	bool ShouldFreeWorkspace = (a_Workspace == nullptr);
 	int ArrayCount = a_SizeX * a_SizeY * a_SizeZ;
 	if (ShouldFreeWorkspace)
 	{
@@ -1123,7 +1123,7 @@ void cRidgedMultiNoise::Generate3D(
 	if (ShouldFreeWorkspace)
 	{
 		delete[] a_Workspace;
-		a_Workspace = NULL;
+		a_Workspace = nullptr;
 	}
 }
 
diff --git a/src/Noise.h b/src/Noise.h
index 4cf8d4ad8..b7a90d5b7 100644
--- a/src/Noise.h
+++ b/src/Noise.h
@@ -155,7 +155,7 @@ public:
 		NOISE_DATATYPE * a_Array,                        ///< Array to generate into
 		int a_SizeX,                                     ///< Count of the array
 		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array
-		NOISE_DATATYPE * a_Workspace = NULL              ///< Workspace that this function can use and trash
+		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
 	) const;
 	
 	
@@ -164,7 +164,7 @@ public:
 		int a_SizeX, int a_SizeY,                        ///< Count of the array, in each direction
 		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
 		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
-		NOISE_DATATYPE * a_Workspace = NULL              ///< Workspace that this function can use and trash
+		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
 	) const;
 	
 	
@@ -174,7 +174,7 @@ public:
 		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
 		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
 		NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ,  ///< Noise-space coords of the array in the Z direction
-		NOISE_DATATYPE * a_Workspace = NULL              ///< Workspace that this function can use and trash
+		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
 	) const;
 	
 protected:
@@ -219,7 +219,7 @@ public:
 		NOISE_DATATYPE * a_Array,                        ///< Array to generate into
 		int a_SizeX,                                     ///< Count of the array
 		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array
-		NOISE_DATATYPE * a_Workspace = NULL              ///< Workspace that this function can use and trash
+		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
 	) const;
 	
 	
@@ -228,7 +228,7 @@ public:
 		int a_SizeX, int a_SizeY,                        ///< Count of the array, in each direction
 		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
 		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
-		NOISE_DATATYPE * a_Workspace = NULL              ///< Workspace that this function can use and trash
+		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
 	) const;
 	
 	
@@ -238,7 +238,7 @@ public:
 		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
 		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
 		NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ,  ///< Noise-space coords of the array in the Z direction
-		NOISE_DATATYPE * a_Workspace = NULL              ///< Workspace that this function can use and trash
+		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
 	) const;
 	
 protected:
diff --git a/src/OSSupport/Errors.cpp b/src/OSSupport/Errors.cpp
index 9401ec257..a5361e1a6 100644
--- a/src/OSSupport/Errors.cpp
+++ b/src/OSSupport/Errors.cpp
@@ -10,7 +10,7 @@ AString GetOSErrorString( int a_ErrNo)
 
 	#ifdef _WIN32
 
-	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, a_ErrNo, 0, buffer, ARRAYCOUNT(buffer), NULL);
+	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, a_ErrNo, 0, buffer, ARRAYCOUNT(buffer), nullptr);
 	Printf(Out, "%d: %s", a_ErrNo, buffer);
 	if (!Out.empty() && (Out[Out.length() - 1] == '\n'))
 	{
@@ -25,7 +25,7 @@ AString GetOSErrorString( int a_ErrNo)
 	#if !defined(__APPLE__) && ( _GNU_SOURCE) && !defined(ANDROID_NDK)  // GNU version of strerror_r()
 	
 	char * res = strerror_r( errno, buffer, ARRAYCOUNT(buffer));
-	if (res != NULL)
+	if (res != nullptr)
 	{
 		Printf(Out, "%d: %s", a_ErrNo, res);
 		return Out;
diff --git a/src/OSSupport/Event.cpp b/src/OSSupport/Event.cpp
index 7cf8a826c..87bc110ce 100644
--- a/src/OSSupport/Event.cpp
+++ b/src/OSSupport/Event.cpp
@@ -15,8 +15,8 @@
 cEvent::cEvent(void)
 {
 #ifdef _WIN32
-	m_Event = CreateEvent(NULL, FALSE, FALSE, NULL);
-	if (m_Event == NULL)
+	m_Event = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+	if (m_Event == nullptr)
 	{
 		LOGERROR("cEvent: cannot create event, GLE = %u. Aborting server.", (unsigned)GetLastError());
 		abort();
@@ -71,7 +71,7 @@ cEvent::~cEvent()
 	{
 		sem_destroy(m_Event);
 		delete m_Event;
-		m_Event = NULL;
+		m_Event = nullptr;
 	}
 #endif
 }
diff --git a/src/OSSupport/File.cpp b/src/OSSupport/File.cpp
index cb6031da6..8957dfaef 100644
--- a/src/OSSupport/File.cpp
+++ b/src/OSSupport/File.cpp
@@ -17,7 +17,7 @@
 
 cFile::cFile(void) :
 	#ifdef USE_STDIO_FILE
-	m_File(NULL)
+	m_File(nullptr)
 	#else
 	m_File(INVALID_HANDLE_VALUE)
 	#endif  // USE_STDIO_FILE
@@ -31,7 +31,7 @@ cFile::cFile(void) :
 
 cFile::cFile(const AString & iFileName, eMode iMode) :
 	#ifdef USE_STDIO_FILE
-	m_File(NULL)
+	m_File(nullptr)
 	#else
 	m_File(INVALID_HANDLE_VALUE)
 	#endif  // USE_STDIO_FILE
@@ -64,7 +64,7 @@ bool cFile::Open(const AString & iFileName, eMode iMode)
 		Close();
 	}
 	
-	const char * Mode = NULL;
+	const char * Mode = nullptr;
 	switch (iMode)
 	{
 		case fmRead:      Mode = "rb";  break;
@@ -72,7 +72,7 @@ bool cFile::Open(const AString & iFileName, eMode iMode)
 		case fmReadWrite: Mode = "rb+"; break;
 		case fmAppend:    Mode = "a+";  break;
 	}
-	if (Mode == NULL)
+	if (Mode == nullptr)
 	{
 		ASSERT(!"Unhandled file mode");
 		return false;
@@ -84,7 +84,7 @@ bool cFile::Open(const AString & iFileName, eMode iMode)
 	m_File = fopen((FILE_IO_PREFIX + iFileName).c_str(), Mode);
 #endif  // _WIN32
 
-	if ((m_File == NULL) && (iMode == fmReadWrite))
+	if ((m_File == nullptr) && (iMode == fmReadWrite))
 	{
 		// Fix for MS not following C spec, opening "a" mode files for writing at the end only
 		// The file open operation has been tried with "read update", fails if file not found
@@ -98,7 +98,7 @@ bool cFile::Open(const AString & iFileName, eMode iMode)
 #endif  // _WIN32
 
 	}
-	return (m_File != NULL);
+	return (m_File != nullptr);
 }
 
 
@@ -114,7 +114,7 @@ void cFile::Close(void)
 	}
 
 	fclose(m_File);
-	m_File = NULL;
+	m_File = nullptr;
 }
 
 
@@ -123,7 +123,7 @@ void cFile::Close(void)
 
 bool cFile::IsOpen(void) const
 {
-	return (m_File != NULL);
+	return (m_File != nullptr);
 }
 
 
@@ -366,7 +366,7 @@ int cFile::GetSize(const AString & a_FileName)
 bool cFile::CreateFolder(const AString & a_FolderPath)
 {
 	#ifdef _WIN32
-		return (CreateDirectoryA(a_FolderPath.c_str(), NULL) != 0);
+		return (CreateDirectoryA(a_FolderPath.c_str(), nullptr) != 0);
 	#else
 		return (mkdir(a_FolderPath.c_str(), S_IRWXU | S_IRWXG | S_IRWXO) == 0);
 	#endif
@@ -415,13 +415,13 @@ AStringVector cFile::GetFolderContents(const AString & a_Folder)
 	{
 		Folder = ".";
 	}
-	if ((dp = opendir(Folder.c_str())) == NULL)
+	if ((dp = opendir(Folder.c_str())) == nullptr)
 	{
 		LOGERROR("Error (%i) opening directory \"%s\"\n", errno, Folder.c_str());
 	}
 	else
 	{
-		while ((dirp = readdir(dp)) != NULL)
+		while ((dirp = readdir(dp)) != nullptr)
 		{
 			AllFiles.push_back(dirp->d_name);
 		}
diff --git a/src/OSSupport/GZipFile.cpp b/src/OSSupport/GZipFile.cpp
index 22d887783..32d84a0d5 100644
--- a/src/OSSupport/GZipFile.cpp
+++ b/src/OSSupport/GZipFile.cpp
@@ -11,7 +11,7 @@
 
 
 cGZipFile::cGZipFile(void) :
-	m_File(NULL), m_Mode(fmRead)
+	m_File(nullptr), m_Mode(fmRead)
 {
 }
 
@@ -30,14 +30,14 @@ cGZipFile::~cGZipFile()
 
 bool cGZipFile::Open(const AString & a_FileName, eMode a_Mode)
 {
-	if (m_File != NULL)
+	if (m_File != nullptr)
 	{
 		ASSERT(!"A file is already open in this object");
 		return false;
 	}
 	m_File = gzopen(a_FileName.c_str(), (a_Mode == fmRead) ? "r" : "w");
 	m_Mode = a_Mode;
-	return (m_File != NULL);
+	return (m_File != nullptr);
 }
 
 
@@ -46,10 +46,10 @@ bool cGZipFile::Open(const AString & a_FileName, eMode a_Mode)
 
 void cGZipFile::Close(void)
 {
-	if (m_File != NULL)
+	if (m_File != nullptr)
 	{
 		gzclose(m_File);
-		m_File = NULL;
+		m_File = nullptr;
 	}
 }
 
@@ -59,7 +59,7 @@ void cGZipFile::Close(void)
 
 int cGZipFile::ReadRestOfFile(AString & a_Contents)
 {
-	if (m_File == NULL)
+	if (m_File == nullptr)
 	{
 		ASSERT(!"No file has been opened");
 		return -1;
@@ -90,7 +90,7 @@ int cGZipFile::ReadRestOfFile(AString & a_Contents)
 
 bool cGZipFile::Write(const char * a_Contents, int a_Size)
 {
-	if (m_File == NULL)
+	if (m_File == nullptr)
 	{
 		ASSERT(!"No file has been opened");
 		return false;
diff --git a/src/OSSupport/ListenThread.cpp b/src/OSSupport/ListenThread.cpp
index 02e98acfc..b029634e9 100644
--- a/src/OSSupport/ListenThread.cpp
+++ b/src/OSSupport/ListenThread.cpp
@@ -214,7 +214,7 @@ void cListenThread::Execute(void)
 		timeval tv;  // On Linux select() doesn't seem to wake up when socket is closed, so let's kinda busy-wait:
 		tv.tv_sec = 1;
 		tv.tv_usec = 0;
-		if (select((int)Highest + 1, &fdRead, NULL, NULL, &tv) == -1)
+		if (select((int)Highest + 1, &fdRead, nullptr, nullptr, &tv) == -1)
 		{
 			LOG("select(R) call failed in cListenThread: \"%s\"", cSocket::GetLastErrorString().c_str());
 			continue;
diff --git a/src/OSSupport/Semaphore.cpp b/src/OSSupport/Semaphore.cpp
index c1fc7d9c7..6a2d57901 100644
--- a/src/OSSupport/Semaphore.cpp
+++ b/src/OSSupport/Semaphore.cpp
@@ -36,7 +36,7 @@ cSemaphore::cSemaphore( unsigned int a_MaxCount, unsigned int a_InitialCount /*
 	}
 #else
 	m_Handle = CreateSemaphore(
-		NULL,  // security attribute
+		nullptr,  // security attribute
 		a_InitialCount,  // initial count
 		a_MaxCount,  // maximum count
 		0  // name (optional)
@@ -98,7 +98,7 @@ void cSemaphore::Signal()
 		LOG("ERROR: Could not signal cSemaphore. (%i)", errno);
 	}
 #else
-	ReleaseSemaphore( m_Handle, 1, NULL);
+	ReleaseSemaphore( m_Handle, 1, nullptr);
 #endif
 }
 
diff --git a/src/OSSupport/Socket.cpp b/src/OSSupport/Socket.cpp
index c07d31c8b..5025a09ad 100644
--- a/src/OSSupport/Socket.cpp
+++ b/src/OSSupport/Socket.cpp
@@ -292,7 +292,7 @@ bool cSocket::ConnectIPv4(const AString & a_HostNameOrAddr, unsigned short a_Por
 	{
 		// It is not an IP Address string, but rather a regular hostname, resolve:
 		hostent * hp = gethostbyname(a_HostNameOrAddr.c_str());
-		if (hp == NULL)
+		if (hp == nullptr)
 		{
 			LOGWARNING("%s: Could not resolve hostname \"%s\"", __FUNCTION__, a_HostNameOrAddr.c_str());
 			CloseSocket();
diff --git a/src/OSSupport/SocketThreads.cpp b/src/OSSupport/SocketThreads.cpp
index f436318a5..7a3ef4274 100644
--- a/src/OSSupport/SocketThreads.cpp
+++ b/src/OSSupport/SocketThreads.cpp
@@ -61,7 +61,7 @@ bool cSocketThreads::AddClient(const cSocket & a_Socket, cCallback * a_Client)
 		// There was an error launching the thread (but it was already logged along with the reason)
 		LOGERROR("A new cSocketThread failed to start");
 		delete Thread;
-		Thread = NULL;
+		Thread = nullptr;
 		return false;
 	}
 	Thread->AddClient(a_Socket, a_Client);
@@ -233,7 +233,7 @@ bool cSocketThreads::cSocketThread::RemoveClient(const cCallback * a_Client)
 				// More data to send, shut down reading and wait for the rest to get sent:
 				m_Slots[i].m_State = sSlot::ssWritingRestOut;
 			}
-			m_Slots[i].m_Client = NULL;
+			m_Slots[i].m_Client = nullptr;
 		}
 		
 		// Notify the thread of the change:
@@ -407,7 +407,7 @@ void cSocketThreads::cSocketThread::Execute(void)
 		timeval Timeout;
 		Timeout.tv_sec = 5;
 		Timeout.tv_usec = 0;
-		if (select((int)Highest + 1, &fdRead, &fdWrite, NULL, &Timeout) == -1)
+		if (select((int)Highest + 1, &fdRead, &fdWrite, nullptr, &Timeout) == -1)
 		{
 			LOG("select() call failed in cSocketThread: \"%s\"", cSocket::GetLastErrorString().c_str());
 			continue;
@@ -519,7 +519,7 @@ void cSocketThreads::cSocketThread::ReadFromSockets(fd_set * a_Read)
 		}
 		else
 		{
-			if (m_Slots[i].m_Client != NULL)
+			if (m_Slots[i].m_Client != nullptr)
 			{
 				m_Slots[i].m_Client->DataReceived(Buffer, Received);
 			}
@@ -545,7 +545,7 @@ void cSocketThreads::cSocketThread::WriteToSockets(fd_set * a_Write)
 		if (m_Slots[i].m_Outgoing.empty())
 		{
 			// Request another chunk of outgoing data:
-			if (m_Slots[i].m_Client != NULL)
+			if (m_Slots[i].m_Client != nullptr)
 			{
 				AString Data;
 				m_Slots[i].m_Client->GetOutgoingData(Data);
@@ -573,7 +573,7 @@ void cSocketThreads::cSocketThread::WriteToSockets(fd_set * a_Write)
 			int Err = cSocket::GetLastError();
 			LOGWARNING("Error %d while writing to client \"%s\", disconnecting. \"%s\"", Err, m_Slots[i].m_Socket.GetIPString().c_str(), GetOSErrorString(Err).c_str());
 			m_Slots[i].m_Socket.CloseSocket();
-			if (m_Slots[i].m_Client != NULL)
+			if (m_Slots[i].m_Client != nullptr)
 			{
 				m_Slots[i].m_Client->SocketClosed();
 			}
@@ -668,7 +668,7 @@ void cSocketThreads::cSocketThread::QueueOutgoingData(void)
 	cCSLock Lock(m_Parent->m_CS);
 	for (int i = 0; i < m_NumSlots; i++)
 	{
-		if (m_Slots[i].m_Client != NULL)
+		if (m_Slots[i].m_Client != nullptr)
 		{
 			AString Data;
 			m_Slots[i].m_Client->GetOutgoingData(Data);
diff --git a/src/OSSupport/SocketThreads.h b/src/OSSupport/SocketThreads.h
index 944f5f3bc..df819468d 100644
--- a/src/OSSupport/SocketThreads.h
+++ b/src/OSSupport/SocketThreads.h
@@ -137,7 +137,7 @@ private:
 			/** The socket is primarily owned by this object */
 			cSocket m_Socket;
 			
-			/** The callback to call for events. May be NULL */
+			/** The callback to call for events. May be nullptr */
 			cCallback * m_Client;
 			
 			/** If sending writes only partial data, the rest is stored here for another send.
diff --git a/src/PolarSSL++/BlockingSslClientSocket.cpp b/src/PolarSSL++/BlockingSslClientSocket.cpp
index 699bc57ee..59e1281ac 100644
--- a/src/PolarSSL++/BlockingSslClientSocket.cpp
+++ b/src/PolarSSL++/BlockingSslClientSocket.cpp
@@ -48,7 +48,7 @@ bool cBlockingSslClientSocket::Connect(const AString & a_ServerName, UInt16 a_Po
 	}
 	
 	// If we have been assigned a trusted CA root cert store, push it into the SSL context:
-	if (m_CACerts.get() != NULL)
+	if (m_CACerts.get() != nullptr)
 	{
 		m_Ssl.SetCACerts(m_CACerts, m_ExpectedPeerName);
 	}
@@ -72,7 +72,7 @@ bool cBlockingSslClientSocket::Connect(const AString & a_ServerName, UInt16 a_Po
 bool cBlockingSslClientSocket::SetTrustedRootCertsFromString(const AString & a_CACerts, const AString & a_ExpectedPeerName)
 {
 	// Warn if used multiple times, but don't signal an error:
-	if (m_CACerts.get() != NULL)
+	if (m_CACerts.get() != nullptr)
 	{
 		LOGWARNING(
 			"SSL: Trying to set multiple trusted CA root cert stores, only the last one will be used. Name: %s",
diff --git a/src/PolarSSL++/CallbackSslContext.cpp b/src/PolarSSL++/CallbackSslContext.cpp
index c4d19b2a0..e061e3f03 100644
--- a/src/PolarSSL++/CallbackSslContext.cpp
+++ b/src/PolarSSL++/CallbackSslContext.cpp
@@ -12,7 +12,7 @@
 
 
 cCallbackSslContext::cCallbackSslContext(void) :
-	m_Callbacks(NULL)
+	m_Callbacks(nullptr)
 {
 	// Nothing needed, but the constructor needs to exist so
 }
@@ -32,7 +32,7 @@ cCallbackSslContext::cCallbackSslContext(cCallbackSslContext::cDataCallbacks & a
 
 int cCallbackSslContext::ReceiveEncrypted(unsigned char * a_Buffer, size_t a_NumBytes)
 {
-	if (m_Callbacks == NULL)
+	if (m_Callbacks == nullptr)
 	{
 		LOGWARNING("SSL: Trying to receive data with no callbacks, aborting.");
 		return POLARSSL_ERR_NET_RECV_FAILED;
@@ -46,7 +46,7 @@ int cCallbackSslContext::ReceiveEncrypted(unsigned char * a_Buffer, size_t a_Num
 
 int cCallbackSslContext::SendEncrypted(const unsigned char * a_Buffer, size_t a_NumBytes)
 {
-	if (m_Callbacks == NULL)
+	if (m_Callbacks == nullptr)
 	{
 		LOGWARNING("SSL: Trying to send data with no callbacks, aborting.");
 		return POLARSSL_ERR_NET_SEND_FAILED;
diff --git a/src/PolarSSL++/CryptoKey.cpp b/src/PolarSSL++/CryptoKey.cpp
index 0763c387b..7c4f021b3 100644
--- a/src/PolarSSL++/CryptoKey.cpp
+++ b/src/PolarSSL++/CryptoKey.cpp
@@ -123,7 +123,7 @@ int cCryptoKey::ParsePrivate(const void * a_Data, size_t a_NumBytes, const AStri
 	
 	if (a_Password.empty())
 	{
-		return pk_parse_key(&m_Pk, (const unsigned char *)a_Data, a_NumBytes, NULL, 0);
+		return pk_parse_key(&m_Pk, (const unsigned char *)a_Data, a_NumBytes, nullptr, 0);
 	}
 	else
 	{
diff --git a/src/PolarSSL++/SslContext.cpp b/src/PolarSSL++/SslContext.cpp
index 482470c3a..902267f90 100644
--- a/src/PolarSSL++/SslContext.cpp
+++ b/src/PolarSSL++/SslContext.cpp
@@ -46,7 +46,7 @@ int cSslContext::Initialize(bool a_IsClient, const SharedPtr<cCtrDrbgContext> &
 	
 	// Set the CtrDrbg context, create a new one if needed:
 	m_CtrDrbg = a_CtrDrbg;
-	if (m_CtrDrbg.get() == NULL)
+	if (m_CtrDrbg.get() == nullptr)
 	{
 		m_CtrDrbg.reset(new cCtrDrbgContext);
 		m_CtrDrbg->Initialize("MCServer", 8);
@@ -98,7 +98,7 @@ void cSslContext::SetOwnCert(const cX509CertPtr & a_OwnCert, const cRsaPrivateKe
 	ASSERT(m_IsValid);  // Call Initialize() first
 	
 	// Check that both the cert and the key is valid:
-	if ((a_OwnCert.get() == NULL) || (a_OwnCertPrivKey.get() == NULL))
+	if ((a_OwnCert.get() == nullptr) || (a_OwnCertPrivKey.get() == nullptr))
 	{
 		LOGWARNING("SSL: Own certificate is not valid, skipping the set.");
 		return;
@@ -121,7 +121,7 @@ void cSslContext::SetOwnCert(const cX509CertPtr & a_OwnCert, const cCryptoKeyPtr
 	ASSERT(m_IsValid);  // Call Initialize() first
 	
 	// Check that both the cert and the key is valid:
-	if ((a_OwnCert.get() == NULL) || (a_OwnCertPrivKey.get() == NULL))
+	if ((a_OwnCert.get() == nullptr) || (a_OwnCertPrivKey.get() == nullptr))
 	{
 		LOGWARNING("SSL: Own certificate is not valid, skipping the set.");
 		return;
@@ -150,7 +150,7 @@ void cSslContext::SetCACerts(const cX509CertPtr & a_CACert, const AString & a_Ex
 	
 	// Set the trusted CA root cert store:
 	ssl_set_authmode(&m_Ssl, SSL_VERIFY_REQUIRED);
-	ssl_set_ca_chain(&m_Ssl, m_CACerts->GetInternal(), NULL, m_ExpectedPeerName.empty() ? NULL : m_ExpectedPeerName.c_str());
+	ssl_set_ca_chain(&m_Ssl, m_CACerts->GetInternal(), nullptr, m_ExpectedPeerName.empty() ? nullptr : m_ExpectedPeerName.c_str());
 }
 
 
diff --git a/src/Protocol/MojangAPI.cpp b/src/Protocol/MojangAPI.cpp
index a4b4dbd3b..dd0d62af5 100644
--- a/src/Protocol/MojangAPI.cpp
+++ b/src/Protocol/MojangAPI.cpp
@@ -196,7 +196,7 @@ cMojangAPI::cMojangAPI(void) :
 	m_NameToUUIDAddress(DEFAULT_NAME_TO_UUID_ADDRESS),
 	m_UUIDToProfileServer(DEFAULT_UUID_TO_PROFILE_SERVER),
 	m_UUIDToProfileAddress(DEFAULT_UUID_TO_PROFILE_ADDRESS),
-	m_RankMgr(NULL),
+	m_RankMgr(nullptr),
 	m_UpdateThread(new cUpdateThread())
 {
 }
@@ -335,7 +335,7 @@ AStringVector cMojangAPI::GetUUIDsFromPlayerNames(const AStringVector & a_Player
 void cMojangAPI::AddPlayerNameToUUIDMapping(const AString & a_PlayerName, const AString & a_UUID)
 {
 	AString UUID = MakeUUIDShort(a_UUID);
-	Int64 Now = time(NULL);
+	Int64 Now = time(nullptr);
 	{
 		cCSLock Lock(m_CSNameToUUID);
 		m_NameToUUID[StrToLower(a_PlayerName)] = sProfile(a_PlayerName, UUID, "", "", Now);
@@ -354,7 +354,7 @@ void cMojangAPI::AddPlayerNameToUUIDMapping(const AString & a_PlayerName, const
 void cMojangAPI::AddPlayerProfile(const AString & a_PlayerName, const AString & a_UUID, const Json::Value & a_Properties)
 {
 	AString UUID = MakeUUIDShort(a_UUID);
-	Int64 Now = time(NULL);
+	Int64 Now = time(nullptr);
 	{
 		cCSLock Lock(m_CSNameToUUID);
 		m_NameToUUID[StrToLower(a_PlayerName)] = sProfile(a_PlayerName, UUID, "", "", Now);
@@ -558,7 +558,7 @@ void cMojangAPI::SaveCachesToDisk(void)
 		db.exec("DELETE FROM UUIDToProfile");
 		
 		// Save all cache entries - m_PlayerNameToUUID:
-		Int64 LimitDateTime = time(NULL) - MAX_AGE;
+		Int64 LimitDateTime = time(nullptr) - MAX_AGE;
 		{
 			SQLite::Statement stmt(db, "INSERT INTO PlayerNameToUUID(PlayerName, UUID, DateTime) VALUES (?, ?, ?)");
 			cCSLock Lock(m_CSNameToUUID);
@@ -697,7 +697,7 @@ void cMojangAPI::QueryNamesToUUIDs(AStringVector & a_NamesToQuery)
 	
 		// Store the returned results into cache:
 		Json::Value::UInt JsonCount = root.size();
-		Int64 Now = time(NULL);
+		Int64 Now = time(nullptr);
 		{
 			cCSLock Lock(m_CSNameToUUID);
 			for (Json::Value::UInt idx = 0; idx < JsonCount; ++idx)
@@ -831,7 +831,7 @@ void cMojangAPI::QueryUUIDToProfile(const AString & a_UUID)
 		return;
 	}
 	Json::Value Properties = root.get("properties", "");
-	Int64 Now = time(NULL);
+	Int64 Now = time(nullptr);
 	{
 		cCSLock Lock(m_CSUUIDToProfile);
 		m_UUIDToProfile[a_UUID] = sProfile(PlayerName, a_UUID, Properties, Now);
@@ -855,7 +855,7 @@ void cMojangAPI::NotifyNameUUID(const AString & a_PlayerName, const AString & a_
 {
 	// Notify the rank manager:
 	cCSLock Lock(m_CSRankMgr);
-	if (m_RankMgr != NULL)
+	if (m_RankMgr != nullptr)
 	{
 		m_RankMgr->NotifyNameUUID(a_PlayerName, a_UUID);
 	}
@@ -867,7 +867,7 @@ void cMojangAPI::NotifyNameUUID(const AString & a_PlayerName, const AString & a_
 
 void cMojangAPI::Update(void)
 {
-	Int64 LimitDateTime = time(NULL) - MAX_AGE;
+	Int64 LimitDateTime = time(nullptr) - MAX_AGE;
 
 	// Re-query all playernames that are stale:
 	AStringVector PlayerNames;
diff --git a/src/Protocol/MojangAPI.h b/src/Protocol/MojangAPI.h
index 393fd4baa..0dc2617b6 100644
--- a/src/Protocol/MojangAPI.h
+++ b/src/Protocol/MojangAPI.h
@@ -89,7 +89,7 @@ public:
 	the profile to the respective mapping caches and updtes their datetime stamp to now. */
 	void AddPlayerProfile(const AString & a_PlayerName, const AString & a_UUID, const Json::Value & a_Properties);
 
-	/** Sets the m_RankMgr that is used for name-uuid notifications. Accepts NULL to remove the binding. */
+	/** Sets the m_RankMgr that is used for name-uuid notifications. Accepts nullptr to remove the binding. */
 	void SetRankManager(cRankManager * a_RankManager) { m_RankMgr = a_RankManager; }
 
 protected:
@@ -112,7 +112,7 @@ protected:
 			m_UUID(),
 			m_Textures(),
 			m_TexturesSignature(),
-			m_DateTime(time(NULL))
+			m_DateTime(time(nullptr))
 		{
 		}
 		
@@ -176,7 +176,7 @@ protected:
 	/** Protects m_UUIDToProfile against simultaneous multi-threaded access. */
 	cCriticalSection m_CSUUIDToProfile;
 
-	/** The rank manager that is notified of the name-uuid pairings. May be NULL. Protected by m_CSRankMgr. */
+	/** The rank manager that is notified of the name-uuid pairings. May be nullptr. Protected by m_CSRankMgr. */
 	cRankManager * m_RankMgr;
 
 	/** Protects m_RankMgr agains simultaneous multi-threaded access. */
diff --git a/src/Protocol/Protocol17x.cpp b/src/Protocol/Protocol17x.cpp
index 204691ede..3baf684e9 100644
--- a/src/Protocol/Protocol17x.cpp
+++ b/src/Protocol/Protocol17x.cpp
@@ -120,7 +120,7 @@ cProtocol172::cProtocol172(cClientHandle * a_Client, const AString & a_ServerAdd
 	{
 		static int sCounter = 0;
 		cFile::CreateFolder("CommLogs");
-		AString FileName = Printf("CommLogs/%x_%d__%s.log", (unsigned)time(NULL), sCounter++, a_Client->GetIPString().c_str());
+		AString FileName = Printf("CommLogs/%x_%d__%s.log", (unsigned)time(nullptr), sCounter++, a_Client->GetIPString().c_str());
 		m_CommLogFile.Open(FileName, cFile::fmWrite);
 	}
 }
@@ -159,7 +159,7 @@ void cProtocol172::SendAttachEntity(const cEntity & a_Entity, const cEntity * a_
 	
 	cPacketizer Pkt(*this, 0x1b);  // Attach Entity packet
 	Pkt.WriteInt(a_Entity.GetUniqueID());
-	Pkt.WriteInt((a_Vehicle != NULL) ? a_Vehicle->GetUniqueID() : 0);
+	Pkt.WriteInt((a_Vehicle != nullptr) ? a_Vehicle->GetUniqueID() : 0);
 	Pkt.WriteBool(false);
 }
 
@@ -254,7 +254,7 @@ void cProtocol172::SendChat(const cCompositeChat & a_Message)
 	ASSERT(m_State == 3);  // In game mode?
 
 	cWorld * World = m_Client->GetPlayer()->GetWorld();
-	bool ShouldUseChatPrefixes = (World == NULL) ? false : World->ShouldUseChatPrefixes();
+	bool ShouldUseChatPrefixes = (World == nullptr) ? false : World->ShouldUseChatPrefixes();
 
 	// Send the message to the client:
 	cPacketizer Pkt(*this, 0x02);
diff --git a/src/Protocol/Protocol18x.cpp b/src/Protocol/Protocol18x.cpp
index c9118c239..0ca9927db 100644
--- a/src/Protocol/Protocol18x.cpp
+++ b/src/Protocol/Protocol18x.cpp
@@ -107,7 +107,7 @@ cProtocol180::cProtocol180(cClientHandle * a_Client, const AString & a_ServerAdd
 	{
 		static int sCounter = 0;
 		cFile::CreateFolder("CommLogs");
-		AString FileName = Printf("CommLogs/%x_%d__%s.log", (unsigned)time(NULL), sCounter++, a_Client->GetIPString().c_str());
+		AString FileName = Printf("CommLogs/%x_%d__%s.log", (unsigned)time(nullptr), sCounter++, a_Client->GetIPString().c_str());
 		m_CommLogFile.Open(FileName, cFile::fmWrite);
 	}
 }
@@ -146,7 +146,7 @@ void cProtocol180::SendAttachEntity(const cEntity & a_Entity, const cEntity * a_
 	
 	cPacketizer Pkt(*this, 0x1b);  // Attach Entity packet
 	Pkt.WriteInt(a_Entity.GetUniqueID());
-	Pkt.WriteInt((a_Vehicle != NULL) ? a_Vehicle->GetUniqueID() : 0);
+	Pkt.WriteInt((a_Vehicle != nullptr) ? a_Vehicle->GetUniqueID() : 0);
 	Pkt.WriteBool(false);
 }
 
@@ -234,7 +234,7 @@ void cProtocol180::SendChat(const cCompositeChat & a_Message)
 	ASSERT(m_State == 3);  // In game mode?
 
 	cWorld * World = m_Client->GetPlayer()->GetWorld();
-	bool ShouldUseChatPrefixes = (World == NULL) ? false : World->ShouldUseChatPrefixes();
+	bool ShouldUseChatPrefixes = (World == nullptr) ? false : World->ShouldUseChatPrefixes();
 
 	// Send the message to the client:
 	cPacketizer Pkt(*this, 0x02);
diff --git a/src/Protocol/ProtocolRecognizer.cpp b/src/Protocol/ProtocolRecognizer.cpp
index 0c1e83b67..af9e0d1bc 100644
--- a/src/Protocol/ProtocolRecognizer.cpp
+++ b/src/Protocol/ProtocolRecognizer.cpp
@@ -22,7 +22,7 @@
 
 cProtocolRecognizer::cProtocolRecognizer(cClientHandle * a_Client) :
 	super(a_Client),
-	m_Protocol(NULL),
+	m_Protocol(nullptr),
 	m_Buffer(8192)     // We need a larger buffer to support BungeeCord - it sends one huge packet at the start
 {
 }
@@ -34,7 +34,7 @@ cProtocolRecognizer::cProtocolRecognizer(cClientHandle * a_Client) :
 cProtocolRecognizer::~cProtocolRecognizer()
 {
 	delete m_Protocol;
-	m_Protocol = NULL;
+	m_Protocol = nullptr;
 }
 
 
@@ -59,7 +59,7 @@ AString cProtocolRecognizer::GetVersionTextFromInt(int a_ProtocolVersion)
 
 void cProtocolRecognizer::DataReceived(const char * a_Data, size_t a_Size)
 {
-	if (m_Protocol == NULL)
+	if (m_Protocol == nullptr)
 	{
 		if (!m_Buffer.Write(a_Data, a_Size))
 		{
@@ -90,7 +90,7 @@ void cProtocolRecognizer::DataReceived(const char * a_Data, size_t a_Size)
 
 void cProtocolRecognizer::SendAttachEntity(const cEntity & a_Entity, const cEntity * a_Vehicle)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendAttachEntity(a_Entity, a_Vehicle);
 }
 
@@ -100,7 +100,7 @@ void cProtocolRecognizer::SendAttachEntity(const cEntity & a_Entity, const cEnti
 
 void cProtocolRecognizer::SendBlockAction(int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendBlockAction(a_BlockX, a_BlockY, a_BlockZ, a_Byte1, a_Byte2, a_BlockType);
 }
 
@@ -110,7 +110,7 @@ void cProtocolRecognizer::SendBlockAction(int a_BlockX, int a_BlockY, int a_Bloc
 
 void cProtocolRecognizer::SendBlockBreakAnim(int a_entityID, int a_BlockX, int a_BlockY, int a_BlockZ, char stage)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendBlockBreakAnim(a_entityID, a_BlockX, a_BlockY, a_BlockZ, stage);
 }
 
@@ -120,7 +120,7 @@ void cProtocolRecognizer::SendBlockBreakAnim(int a_entityID, int a_BlockX, int a
 
 void cProtocolRecognizer::SendBlockChange(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendBlockChange(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
 }
 
@@ -130,7 +130,7 @@ void cProtocolRecognizer::SendBlockChange(int a_BlockX, int a_BlockY, int a_Bloc
 
 void cProtocolRecognizer::SendBlockChanges(int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendBlockChanges(a_ChunkX, a_ChunkZ, a_Changes);
 }
 
@@ -140,7 +140,7 @@ void cProtocolRecognizer::SendBlockChanges(int a_ChunkX, int a_ChunkZ, const sSe
 
 void cProtocolRecognizer::SendChat(const AString & a_Message)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendChat(a_Message);
 }
 
@@ -150,7 +150,7 @@ void cProtocolRecognizer::SendChat(const AString & a_Message)
 
 void cProtocolRecognizer::SendChat(const cCompositeChat & a_Message)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendChat(a_Message);
 }
 
@@ -160,7 +160,7 @@ void cProtocolRecognizer::SendChat(const cCompositeChat & a_Message)
 
 void cProtocolRecognizer::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendChunkData(a_ChunkX, a_ChunkZ, a_Serializer);
 }
 
@@ -170,7 +170,7 @@ void cProtocolRecognizer::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSe
 
 void cProtocolRecognizer::SendCollectEntity(const cEntity & a_Entity, const cPlayer & a_Player)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendCollectEntity(a_Entity, a_Player);
 }
 
@@ -180,7 +180,7 @@ void cProtocolRecognizer::SendCollectEntity(const cEntity & a_Entity, const cPla
 
 void cProtocolRecognizer::SendDestroyEntity(const cEntity & a_Entity)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendDestroyEntity(a_Entity);
 }
 
@@ -190,7 +190,7 @@ void cProtocolRecognizer::SendDestroyEntity(const cEntity & a_Entity)
 
 void cProtocolRecognizer::SendDisconnect(const AString & a_Reason)
 {
-	if (m_Protocol != NULL)
+	if (m_Protocol != nullptr)
 	{
 		m_Protocol->SendDisconnect(a_Reason);
 	}
@@ -212,7 +212,7 @@ void cProtocolRecognizer::SendDisconnect(const AString & a_Reason)
 
 void cProtocolRecognizer::SendEditSign(int a_BlockX, int a_BlockY, int a_BlockZ)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEditSign(a_BlockX, a_BlockY, a_BlockZ);
 }
 
@@ -222,7 +222,7 @@ void cProtocolRecognizer::SendEditSign(int a_BlockX, int a_BlockY, int a_BlockZ)
 
 void cProtocolRecognizer::SendEntityEffect(const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityEffect(a_Entity, a_EffectID, a_Amplifier, a_Duration);
 }
 
@@ -232,7 +232,7 @@ void cProtocolRecognizer::SendEntityEffect(const cEntity & a_Entity, int a_Effec
 
 void cProtocolRecognizer::SendEntityEquipment(const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityEquipment(a_Entity, a_SlotNum, a_Item);
 }
 
@@ -242,7 +242,7 @@ void cProtocolRecognizer::SendEntityEquipment(const cEntity & a_Entity, short a_
 
 void cProtocolRecognizer::SendEntityHeadLook(const cEntity & a_Entity)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityHeadLook(a_Entity);
 }
 
@@ -252,7 +252,7 @@ void cProtocolRecognizer::SendEntityHeadLook(const cEntity & a_Entity)
 
 void cProtocolRecognizer::SendEntityLook(const cEntity & a_Entity)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityLook(a_Entity);
 }
 
@@ -262,7 +262,7 @@ void cProtocolRecognizer::SendEntityLook(const cEntity & a_Entity)
 
 void cProtocolRecognizer::SendEntityMetadata(const cEntity & a_Entity)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityMetadata(a_Entity);
 }
 
@@ -272,7 +272,7 @@ void cProtocolRecognizer::SendEntityMetadata(const cEntity & a_Entity)
 
 void cProtocolRecognizer::SendEntityProperties(const cEntity & a_Entity)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityProperties(a_Entity);
 }
 
@@ -282,7 +282,7 @@ void cProtocolRecognizer::SendEntityProperties(const cEntity & a_Entity)
 
 void cProtocolRecognizer::SendEntityRelMove(const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityRelMove(a_Entity, a_RelX, a_RelY, a_RelZ);
 }
 
@@ -292,7 +292,7 @@ void cProtocolRecognizer::SendEntityRelMove(const cEntity & a_Entity, char a_Rel
 
 void cProtocolRecognizer::SendEntityRelMoveLook(const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityRelMoveLook(a_Entity, a_RelX, a_RelY, a_RelZ);
 }
 
@@ -302,7 +302,7 @@ void cProtocolRecognizer::SendEntityRelMoveLook(const cEntity & a_Entity, char a
 
 void cProtocolRecognizer::SendEntityStatus(const cEntity & a_Entity, char a_Status)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityStatus(a_Entity, a_Status);
 }
 
@@ -312,7 +312,7 @@ void cProtocolRecognizer::SendEntityStatus(const cEntity & a_Entity, char a_Stat
 
 void cProtocolRecognizer::SendEntityVelocity(const cEntity & a_Entity)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityVelocity(a_Entity);
 }
 
@@ -322,7 +322,7 @@ void cProtocolRecognizer::SendEntityVelocity(const cEntity & a_Entity)
 
 void cProtocolRecognizer::SendExplosion(double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendExplosion(a_BlockX, a_BlockY, a_BlockZ, a_Radius, a_BlocksAffected, a_PlayerMotion);
 }
 
@@ -332,7 +332,7 @@ void cProtocolRecognizer::SendExplosion(double a_BlockX, double a_BlockY, double
 
 void cProtocolRecognizer::SendGameMode(eGameMode a_GameMode)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendGameMode(a_GameMode);
 }
 
@@ -342,7 +342,7 @@ void cProtocolRecognizer::SendGameMode(eGameMode a_GameMode)
 
 void cProtocolRecognizer::SendHealth(void)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendHealth();
 }
 
@@ -352,7 +352,7 @@ void cProtocolRecognizer::SendHealth(void)
 
 void cProtocolRecognizer::SendWindowProperty(const cWindow & a_Window, short a_Property, short a_Value)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendWindowProperty(a_Window, a_Property, a_Value);
 }
 
@@ -362,7 +362,7 @@ void cProtocolRecognizer::SendWindowProperty(const cWindow & a_Window, short a_P
 
 void cProtocolRecognizer::SendInventorySlot(char a_WindowID, short a_SlotNum, const cItem & a_Item)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendInventorySlot(a_WindowID, a_SlotNum, a_Item);
 }
 
@@ -372,7 +372,7 @@ void cProtocolRecognizer::SendInventorySlot(char a_WindowID, short a_SlotNum, co
 
 void cProtocolRecognizer::SendKeepAlive(int a_PingID)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendKeepAlive(a_PingID);
 }
 
@@ -382,7 +382,7 @@ void cProtocolRecognizer::SendKeepAlive(int a_PingID)
 
 void cProtocolRecognizer::SendLogin(const cPlayer & a_Player, const cWorld & a_World)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendLogin(a_Player, a_World);
 }
 
@@ -392,7 +392,7 @@ void cProtocolRecognizer::SendLogin(const cPlayer & a_Player, const cWorld & a_W
 
 void cProtocolRecognizer::SendLoginSuccess(void)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendLoginSuccess();
 }
 
@@ -402,7 +402,7 @@ void cProtocolRecognizer::SendLoginSuccess(void)
 
 void cProtocolRecognizer::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendMapColumn(a_ID, a_X, a_Y, a_Colors, a_Length, m_Scale);
 }
 
@@ -412,7 +412,7 @@ void cProtocolRecognizer::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte *
 
 void cProtocolRecognizer::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendMapDecorators(a_ID, a_Decorators, m_Scale);
 }
 
@@ -422,7 +422,7 @@ void cProtocolRecognizer::SendMapDecorators(int a_ID, const cMapDecoratorList &
 
 void cProtocolRecognizer::SendMapInfo(int a_ID, unsigned int a_Scale)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendMapInfo(a_ID, a_Scale);
 }
 
@@ -432,7 +432,7 @@ void cProtocolRecognizer::SendMapInfo(int a_ID, unsigned int a_Scale)
 
 void cProtocolRecognizer::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmount);
 }
 
@@ -450,7 +450,7 @@ void cProtocolRecognizer::SendPaintingSpawn(const cPainting & a_Painting)
 
 void cProtocolRecognizer::SendPickupSpawn(const cPickup & a_Pickup)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPickupSpawn(a_Pickup);
 }
 
@@ -460,7 +460,7 @@ void cProtocolRecognizer::SendPickupSpawn(const cPickup & a_Pickup)
 
 void cProtocolRecognizer::SendPlayerAbilities(void)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPlayerAbilities();
 }
 
@@ -470,7 +470,7 @@ void cProtocolRecognizer::SendPlayerAbilities(void)
 
 void cProtocolRecognizer::SendEntityAnimation(const cEntity & a_Entity, char a_Animation)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendEntityAnimation(a_Entity, a_Animation);
 }
 
@@ -480,7 +480,7 @@ void cProtocolRecognizer::SendEntityAnimation(const cEntity & a_Entity, char a_A
 
 void cProtocolRecognizer::SendPlayerListAddPlayer(const cPlayer & a_Player)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPlayerListAddPlayer(a_Player);
 }
 
@@ -490,7 +490,7 @@ void cProtocolRecognizer::SendPlayerListAddPlayer(const cPlayer & a_Player)
 
 void cProtocolRecognizer::SendPlayerListRemovePlayer(const cPlayer & a_Player)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPlayerListRemovePlayer(a_Player);
 }
 
@@ -500,7 +500,7 @@ void cProtocolRecognizer::SendPlayerListRemovePlayer(const cPlayer & a_Player)
 
 void cProtocolRecognizer::SendPlayerListUpdateGameMode(const cPlayer & a_Player)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPlayerListUpdateGameMode(a_Player);
 }
 
@@ -510,7 +510,7 @@ void cProtocolRecognizer::SendPlayerListUpdateGameMode(const cPlayer & a_Player)
 
 void cProtocolRecognizer::SendPlayerListUpdatePing(const cPlayer & a_Player)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPlayerListUpdatePing(a_Player);
 }
 
@@ -520,7 +520,7 @@ void cProtocolRecognizer::SendPlayerListUpdatePing(const cPlayer & a_Player)
 
 void cProtocolRecognizer::SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPlayerListUpdateDisplayName(a_Player, a_CustomName);
 }
 
@@ -530,7 +530,7 @@ void cProtocolRecognizer::SendPlayerListUpdateDisplayName(const cPlayer & a_Play
 
 void cProtocolRecognizer::SendPlayerMaxSpeed(void)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPlayerMaxSpeed();
 }
 
@@ -540,7 +540,7 @@ void cProtocolRecognizer::SendPlayerMaxSpeed(void)
 
 void cProtocolRecognizer::SendPlayerMoveLook(void)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPlayerMoveLook();
 }
 
@@ -550,7 +550,7 @@ void cProtocolRecognizer::SendPlayerMoveLook(void)
 
 void cProtocolRecognizer::SendPlayerPosition(void)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPlayerPosition();
 }
 
@@ -560,7 +560,7 @@ void cProtocolRecognizer::SendPlayerPosition(void)
 
 void cProtocolRecognizer::SendPlayerSpawn(const cPlayer & a_Player)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPlayerSpawn(a_Player);
 }
 
@@ -570,7 +570,7 @@ void cProtocolRecognizer::SendPlayerSpawn(const cPlayer & a_Player)
 
 void cProtocolRecognizer::SendPluginMessage(const AString & a_Channel, const AString & a_Message)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendPluginMessage(a_Channel, a_Message);
 }
 
@@ -580,7 +580,7 @@ void cProtocolRecognizer::SendPluginMessage(const AString & a_Channel, const ASt
 
 void cProtocolRecognizer::SendRemoveEntityEffect(const cEntity & a_Entity, int a_EffectID)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendRemoveEntityEffect(a_Entity, a_EffectID);
 }
 
@@ -590,7 +590,7 @@ void cProtocolRecognizer::SendRemoveEntityEffect(const cEntity & a_Entity, int a
 
 void cProtocolRecognizer::SendRespawn(eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendRespawn(a_Dimension, a_ShouldIgnoreDimensionChecks);
 }
 
@@ -600,7 +600,7 @@ void cProtocolRecognizer::SendRespawn(eDimension a_Dimension, bool a_ShouldIgnor
 
 void cProtocolRecognizer::SendExperience(void)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendExperience();
 }
 
@@ -610,7 +610,7 @@ void cProtocolRecognizer::SendExperience(void)
 
 void cProtocolRecognizer::SendExperienceOrb(const cExpOrb & a_ExpOrb)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendExperienceOrb(a_ExpOrb);
 }
 
@@ -620,7 +620,7 @@ void cProtocolRecognizer::SendExperienceOrb(const cExpOrb & a_ExpOrb)
 
 void cProtocolRecognizer::SendScoreboardObjective(const AString & a_Name, const AString & a_DisplayName, Byte a_Mode)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendScoreboardObjective(a_Name, a_DisplayName, a_Mode);
 }
 
@@ -630,7 +630,7 @@ void cProtocolRecognizer::SendScoreboardObjective(const AString & a_Name, const
 
 void cProtocolRecognizer::SendScoreUpdate(const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendScoreUpdate(a_Objective, a_Player, a_Score, a_Mode);
 }
 
@@ -640,7 +640,7 @@ void cProtocolRecognizer::SendScoreUpdate(const AString & a_Objective, const ASt
 
 void cProtocolRecognizer::SendDisplayObjective(const AString & a_Objective, cScoreboard::eDisplaySlot a_Display)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendDisplayObjective(a_Objective, a_Display);
 }
 
@@ -650,7 +650,7 @@ void cProtocolRecognizer::SendDisplayObjective(const AString & a_Objective, cSco
 
 void cProtocolRecognizer::SendSoundEffect(const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendSoundEffect(a_SoundName, a_X, a_Y, a_Z, a_Volume, a_Pitch);
 }
 
@@ -660,7 +660,7 @@ void cProtocolRecognizer::SendSoundEffect(const AString & a_SoundName, double a_
 
 void cProtocolRecognizer::SendSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendSoundParticleEffect(a_EffectID, a_SrcX, a_SrcY, a_SrcZ, a_Data);
 }
 
@@ -670,7 +670,7 @@ void cProtocolRecognizer::SendSoundParticleEffect(int a_EffectID, int a_SrcX, in
 
 void cProtocolRecognizer::SendSpawnFallingBlock(const cFallingBlock & a_FallingBlock)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendSpawnFallingBlock(a_FallingBlock);
 }
 
@@ -680,7 +680,7 @@ void cProtocolRecognizer::SendSpawnFallingBlock(const cFallingBlock & a_FallingB
 
 void cProtocolRecognizer::SendSpawnMob(const cMonster & a_Mob)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendSpawnMob(a_Mob);
 }
 
@@ -690,7 +690,7 @@ void cProtocolRecognizer::SendSpawnMob(const cMonster & a_Mob)
 
 void cProtocolRecognizer::SendSpawnObject(const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendSpawnObject(a_Entity, a_ObjectType, a_ObjectData, a_Yaw, a_Pitch);
 }
 
@@ -700,7 +700,7 @@ void cProtocolRecognizer::SendSpawnObject(const cEntity & a_Entity, char a_Objec
 
 void cProtocolRecognizer::SendSpawnVehicle(const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendSpawnVehicle(a_Vehicle, a_VehicleType, a_VehicleSubType);
 }
 
@@ -710,7 +710,7 @@ void cProtocolRecognizer::SendSpawnVehicle(const cEntity & a_Vehicle, char a_Veh
 
 void cProtocolRecognizer::SendStatistics(const cStatManager & a_Manager)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendStatistics(a_Manager);
 }
 
@@ -720,7 +720,7 @@ void cProtocolRecognizer::SendStatistics(const cStatManager & a_Manager)
 
 void cProtocolRecognizer::SendTabCompletionResults(const AStringVector & a_Results)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendTabCompletionResults(a_Results);
 }
 
@@ -730,7 +730,7 @@ void cProtocolRecognizer::SendTabCompletionResults(const AStringVector & a_Resul
 
 void cProtocolRecognizer::SendTeleportEntity(const cEntity & a_Entity)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendTeleportEntity(a_Entity);
 }
 
@@ -740,7 +740,7 @@ void cProtocolRecognizer::SendTeleportEntity(const cEntity & a_Entity)
 
 void cProtocolRecognizer::SendThunderbolt(int a_BlockX, int a_BlockY, int a_BlockZ)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendThunderbolt(a_BlockX, a_BlockY, a_BlockZ);
 }
 
@@ -750,7 +750,7 @@ void cProtocolRecognizer::SendThunderbolt(int a_BlockX, int a_BlockY, int a_Bloc
 
 void cProtocolRecognizer::SendTimeUpdate(Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendTimeUpdate(a_WorldAge, a_TimeOfDay, a_DoDaylightCycle);
 }
 
@@ -760,7 +760,7 @@ void cProtocolRecognizer::SendTimeUpdate(Int64 a_WorldAge, Int64 a_TimeOfDay, bo
 
 void cProtocolRecognizer::SendUnloadChunk(int a_ChunkX, int a_ChunkZ)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendUnloadChunk(a_ChunkX, a_ChunkZ);
 }
 
@@ -770,7 +770,7 @@ void cProtocolRecognizer::SendUnloadChunk(int a_ChunkX, int a_ChunkZ)
 
 void cProtocolRecognizer::SendUpdateBlockEntity(cBlockEntity & a_BlockEntity)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendUpdateBlockEntity(a_BlockEntity);
 }
 
@@ -780,7 +780,7 @@ void cProtocolRecognizer::SendUpdateBlockEntity(cBlockEntity & a_BlockEntity)
 
 void cProtocolRecognizer::SendUpdateSign(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendUpdateSign(a_BlockX, a_BlockY, a_BlockZ, a_Line1, a_Line2, a_Line3, a_Line4);
 }
 
@@ -790,7 +790,7 @@ void cProtocolRecognizer::SendUpdateSign(int a_BlockX, int a_BlockY, int a_Block
 
 void cProtocolRecognizer::SendUseBed(const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendUseBed(a_Entity, a_BlockX, a_BlockY, a_BlockZ);
 }
 
@@ -800,7 +800,7 @@ void cProtocolRecognizer::SendUseBed(const cEntity & a_Entity, int a_BlockX, int
 
 void cProtocolRecognizer::SendWeather(eWeather a_Weather)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendWeather(a_Weather);
 }
 
@@ -810,7 +810,7 @@ void cProtocolRecognizer::SendWeather(eWeather a_Weather)
 
 void cProtocolRecognizer::SendWholeInventory(const cWindow & a_Window)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendWholeInventory(a_Window);
 }
 
@@ -820,7 +820,7 @@ void cProtocolRecognizer::SendWholeInventory(const cWindow & a_Window)
 
 void cProtocolRecognizer::SendWindowClose(const cWindow & a_Window)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendWindowClose(a_Window);
 }
 
@@ -830,7 +830,7 @@ void cProtocolRecognizer::SendWindowClose(const cWindow & a_Window)
 
 void cProtocolRecognizer::SendWindowOpen(const cWindow & a_Window)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	m_Protocol->SendWindowOpen(a_Window);
 }
 
@@ -840,7 +840,7 @@ void cProtocolRecognizer::SendWindowOpen(const cWindow & a_Window)
 
 AString cProtocolRecognizer::GetAuthServerID(void)
 {
-	ASSERT(m_Protocol != NULL);
+	ASSERT(m_Protocol != nullptr);
 	return m_Protocol->GetAuthServerID();
 }
 
diff --git a/src/RCONServer.cpp b/src/RCONServer.cpp
index 141c67d1b..df027c91f 100644
--- a/src/RCONServer.cpp
+++ b/src/RCONServer.cpp
@@ -242,7 +242,7 @@ bool cRCONServer::cConnection::ProcessPacket(int a_RequestID, int a_PacketType,
 			if (strncmp(a_Payload, m_RCONServer.m_Password.c_str(), a_PayloadLength) != 0)
 			{
 				LOGINFO("RCON: Invalid password from client %s, dropping connection.", m_IPAddress.c_str());
-				SendResponse(-1, RCON_PACKET_RESPONSE, 0, NULL);
+				SendResponse(-1, RCON_PACKET_RESPONSE, 0, nullptr);
 				return false;
 			}
 			m_IsAuthenticated = true;
@@ -250,7 +250,7 @@ bool cRCONServer::cConnection::ProcessPacket(int a_RequestID, int a_PacketType,
 			LOGD("RCON: Client at %s has successfully authenticated", m_IPAddress.c_str());
 			
 			// Send OK response:
-			SendResponse(a_RequestID, RCON_PACKET_RESPONSE, 0, NULL);
+			SendResponse(a_RequestID, RCON_PACKET_RESPONSE, 0, nullptr);
 			return true;
 		}
 		
@@ -268,7 +268,7 @@ bool cRCONServer::cConnection::ProcessPacket(int a_RequestID, int a_PacketType,
 			cRoot::Get()->ExecuteConsoleCommand(cmd, *(new cRCONCommandOutput(*this, a_RequestID)));
 			
 			// Send an empty response:
-			SendResponse(a_RequestID, RCON_PACKET_RESPONSE, 0, NULL);
+			SendResponse(a_RequestID, RCON_PACKET_RESPONSE, 0, nullptr);
 			return true;
 		}
 	}
@@ -310,7 +310,7 @@ void cRCONServer::cConnection::IntToBuffer(int a_Value, char * a_Buffer)
 /// Sends a RCON packet back to the client
 void cRCONServer::cConnection::SendResponse(int a_RequestID, int a_PacketType, int a_PayloadLength, const char * a_Payload)
 {
-	ASSERT((a_PayloadLength == 0) || (a_Payload != NULL));  // Either zero data to send, or a valid payload ptr
+	ASSERT((a_PayloadLength == 0) || (a_Payload != nullptr));  // Either zero data to send, or a valid payload ptr
 	
 	char Buffer[4];
 	int Length = a_PayloadLength + 10;
diff --git a/src/RankManager.cpp b/src/RankManager.cpp
index f5342ed3d..3778f5d64 100644
--- a/src/RankManager.cpp
+++ b/src/RankManager.cpp
@@ -384,7 +384,7 @@ protected:
 cRankManager::cRankManager(void) :
 	m_DB("Ranks.sqlite", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE),
 	m_IsInitialized(false),
-	m_MojangAPI(NULL)
+	m_MojangAPI(nullptr)
 {
 }
 
@@ -394,9 +394,9 @@ cRankManager::cRankManager(void) :
 
 cRankManager::~cRankManager()
 {
-	if (m_MojangAPI != NULL)
+	if (m_MojangAPI != nullptr)
 	{
-		m_MojangAPI->SetRankManager(NULL);
+		m_MojangAPI->SetRankManager(nullptr);
 	}
 }
 
diff --git a/src/RankManager.h b/src/RankManager.h
index 61c52fda6..5dff634b5 100644
--- a/src/RankManager.h
+++ b/src/RankManager.h
@@ -240,7 +240,7 @@ protected:
 	bool m_IsInitialized;
 
 	/** The MojangAPI instance that is used for translating playernames to UUIDs.
-	Set in Initialize(), may be NULL. */
+	Set in Initialize(), may be nullptr. */
 	cMojangAPI * m_MojangAPI;
 	
 	
diff --git a/src/Root.cpp b/src/Root.cpp
index 1271e8648..c951cb891 100644
--- a/src/Root.cpp
+++ b/src/Root.cpp
@@ -34,20 +34,20 @@
 
 
 
-cRoot* cRoot::s_Root = NULL;
+cRoot* cRoot::s_Root = nullptr;
 
 
 
 
 
 cRoot::cRoot(void) :
-	m_pDefaultWorld(NULL),
-	m_Server(NULL),
-	m_MonsterConfig(NULL),
-	m_CraftingRecipes(NULL),
-	m_FurnaceRecipe(NULL),
-	m_WebAdmin(NULL),
-	m_PluginManager(NULL),
+	m_pDefaultWorld(nullptr),
+	m_Server(nullptr),
+	m_MonsterConfig(nullptr),
+	m_CraftingRecipes(nullptr),
+	m_FurnaceRecipe(nullptr),
+	m_WebAdmin(nullptr),
+	m_PluginManager(nullptr),
 	m_bStop(false),
 	m_bRestart(false)
 {
@@ -224,21 +224,21 @@ void cRoot::Start(void)
 		m_Authenticator.Stop();
 
 		LOGD("Freeing MonsterConfig...");
-		delete m_MonsterConfig; m_MonsterConfig = NULL;
-		delete m_WebAdmin; m_WebAdmin = NULL;
+		delete m_MonsterConfig; m_MonsterConfig = nullptr;
+		delete m_WebAdmin; m_WebAdmin = nullptr;
 		LOGD("Unloading recipes...");
-		delete m_FurnaceRecipe;   m_FurnaceRecipe = NULL;
-		delete m_CraftingRecipes; m_CraftingRecipes = NULL;
+		delete m_FurnaceRecipe;   m_FurnaceRecipe = nullptr;
+		delete m_CraftingRecipes; m_CraftingRecipes = nullptr;
 		LOGD("Unloading worlds...");
 		UnloadWorlds();
 		
 		LOGD("Stopping plugin manager...");
-		delete m_PluginManager; m_PluginManager = NULL;
+		delete m_PluginManager; m_PluginManager = nullptr;
 
 		cItemHandler::Deinit();
 
 		LOG("Cleaning up...");
-		delete m_Server; m_Server = NULL;
+		delete m_Server; m_Server = nullptr;
 		LOG("Shutdown successful!");
 	}
 	
@@ -313,7 +313,7 @@ void cRoot::LoadWorlds(cIniFile & IniFile)
 cWorld * cRoot::CreateAndInitializeWorld(const AString & a_WorldName, eDimension a_Dimension, const AString & a_OverworldName)
 {
 	cWorld * World = m_WorldsByName[a_WorldName];
-	if (World != NULL)
+	if (World != nullptr)
 	{
 		return World;
 	}
@@ -358,7 +358,7 @@ void cRoot::StopWorlds(void)
 
 void cRoot::UnloadWorlds(void)
 {
-	m_pDefaultWorld = NULL;
+	m_pDefaultWorld = nullptr;
 	for (WorldMap::iterator itr = m_WorldsByName.begin(); itr != m_WorldsByName.end(); ++itr)
 	{
 		delete itr->second;
@@ -391,7 +391,7 @@ cWorld * cRoot::GetWorld(const AString & a_WorldName, bool a_SearchForFolder)
 	{
 		return CreateAndInitializeWorld(a_WorldName);
 	}
-	return NULL;
+	return nullptr;
 }
 
 
@@ -403,7 +403,7 @@ bool cRoot::ForEachWorld(cWorldListCallback & a_Callback)
 	for (WorldMap::iterator itr = m_WorldsByName.begin(), itr2 = itr; itr != m_WorldsByName.end(); itr = itr2)
 	{
 		++itr2;
-		if (itr->second != NULL)
+		if (itr->second != nullptr)
 		{
 			if (a_Callback.Item(itr->second))
 			{
@@ -538,7 +538,7 @@ void cRoot::BroadcastChat(const AString & a_Message, eMessageType a_ChatPrefix)
 {
 	for (WorldMap::iterator itr = m_WorldsByName.begin(), end = m_WorldsByName.end(); itr != end; ++itr)
 	{
-		itr->second->BroadcastChat(a_Message, NULL, a_ChatPrefix);
+		itr->second->BroadcastChat(a_Message, nullptr, a_ChatPrefix);
 	}  // for itr - m_WorldsByName[]
 }
 
@@ -608,7 +608,7 @@ bool cRoot::FindAndDoWithPlayer(const AString & a_PlayerName, cPlayerListCallbac
 			m_BestRating(0),
 			m_NameLength(a_PlayerName.length()),
 			m_PlayerName(a_PlayerName),
-			m_BestMatch(NULL),
+			m_BestMatch(nullptr),
 			m_NumMatches(0)
 		{}
 
diff --git a/src/Scoreboard.cpp b/src/Scoreboard.cpp
index def952029..adce8b549 100644
--- a/src/Scoreboard.cpp
+++ b/src/Scoreboard.cpp
@@ -278,7 +278,7 @@ cScoreboard::cScoreboard(cWorld * a_World) : m_World(a_World)
 {
 	for (int i = 0; i < (int) dsCount; ++i)
 	{
-		m_Display[i] = NULL;
+		m_Display[i] = nullptr;
 	}
 }
 
@@ -294,14 +294,14 @@ cObjective* cScoreboard::RegisterObjective(const AString & a_Name, const AString
 
 	if (Status.second)
 	{
-		ASSERT(m_World != NULL);
+		ASSERT(m_World != nullptr);
 		m_World->BroadcastScoreboardObjective(a_Name, a_DisplayName, 0);
 
 		return &Status.first->second;
 	}
 	else
 	{
-		return NULL;
+		return nullptr;
 	}
 }
 
@@ -320,14 +320,14 @@ bool cScoreboard::RemoveObjective(const AString & a_Name)
 		return false;
 	}
 
-	ASSERT(m_World != NULL);
+	ASSERT(m_World != nullptr);
 	m_World->BroadcastScoreboardObjective(it->second.GetName(), it->second.GetDisplayName(), 1);
 
 	for (unsigned int i = 0; i < (unsigned int) dsCount; ++i)
 	{
 		if (m_Display[i] == &it->second)
 		{
-			SetDisplay(NULL, (eDisplaySlot) i);
+			SetDisplay(nullptr, (eDisplaySlot) i);
 		}
 	}
 
@@ -348,7 +348,7 @@ cObjective * cScoreboard::GetObjective(const AString & a_Name)
 
 	if (it == m_Objectives.end())
 	{
-		return NULL;
+		return nullptr;
 	}
 	else
 	{
@@ -369,7 +369,7 @@ cTeam * cScoreboard::RegisterTeam(
 
 	std::pair<cTeamMap::iterator, bool> Status = m_Teams.insert(cNamedTeam(a_Name, Team));
 
-	return Status.second ? &Status.first->second : NULL;
+	return Status.second ? &Status.first->second : nullptr;
 }
 
 
@@ -404,7 +404,7 @@ cTeam * cScoreboard::GetTeam(const AString & a_Name)
 
 	if (it == m_Teams.end())
 	{
-		return NULL;
+		return nullptr;
 	}
 	else
 	{
@@ -428,7 +428,7 @@ cTeam * cScoreboard::QueryPlayerTeam(const AString & a_Name)
 		}
 	}
 
-	return NULL;
+	return nullptr;
 }
 
 
@@ -452,7 +452,7 @@ void cScoreboard::SetDisplay(cObjective * a_Objective, eDisplaySlot a_Slot)
 {
 	m_Display[a_Slot] = a_Objective;
 
-	ASSERT(m_World != NULL);
+	ASSERT(m_World != nullptr);
 	m_World->BroadcastDisplayObjective(a_Objective ? a_Objective->GetName() : "", a_Slot);
 }
 
diff --git a/src/Scoreboard.h b/src/Scoreboard.h
index f53b8c803..dd4073c89 100644
--- a/src/Scoreboard.h
+++ b/src/Scoreboard.h
@@ -226,22 +226,22 @@ public:
 
 	// tolua_begin
 
-	/** Registers a new scoreboard objective, returns the cObjective instance, NULL on name collision */
+	/** Registers a new scoreboard objective, returns the cObjective instance, nullptr on name collision */
 	cObjective * RegisterObjective(const AString & a_Name, const AString & a_DisplayName, cObjective::eType a_Type);
 
 	/** Removes a registered objective, returns true if operation was successful */
 	bool RemoveObjective(const AString & a_Name);
 
-	/** Retrieves the objective with the specified name, NULL if not found */
+	/** Retrieves the objective with the specified name, nullptr if not found */
 	cObjective * GetObjective(const AString & a_Name);
 
-	/** Registers a new team, returns the cTeam instance, NULL on name collision */
+	/** Registers a new team, returns the cTeam instance, nullptr on name collision */
 	cTeam * RegisterTeam(const AString & a_Name, const AString & a_DisplayName, const AString & a_Prefix, const AString & a_Suffix);
 
 	/** Removes a registered team, returns true if operation was successful */
 	bool RemoveTeam(const AString & a_Name);
 
-	/** Retrieves the team with the specified name, NULL if not found */
+	/** Retrieves the team with the specified name, nullptr if not found */
 	cTeam * GetTeam(const AString & a_Name);
 
 	void SetDisplay(const AString & a_Objective, eDisplaySlot a_Slot);
diff --git a/src/Server.cpp b/src/Server.cpp
index 38e5cebb3..11da36868 100644
--- a/src/Server.cpp
+++ b/src/Server.cpp
@@ -332,7 +332,7 @@ void cServer::OnConnectionAccepted(cSocket & a_Socket)
 		LOGERROR("Client \"%s\" cannot be handled, server probably unstable", ClientIP.c_str());
 		a_Socket.CloseSocket();
 		delete NewHandle;
-		NewHandle = NULL;
+		NewHandle = nullptr;
 		return;
 	}
 	
@@ -631,17 +631,17 @@ void cServer::PrintHelp(const AStringVector & a_Split, cCommandOutputCallback &
 void cServer::BindBuiltInConsoleCommands(void)
 {
 	cPluginManager * PlgMgr = cPluginManager::Get();
-	PlgMgr->BindConsoleCommand("help", NULL, " - Shows the available commands");
-	PlgMgr->BindConsoleCommand("reload", NULL, " - Reloads all plugins");
-	PlgMgr->BindConsoleCommand("restart", NULL, " - Restarts the server cleanly");
-	PlgMgr->BindConsoleCommand("stop", NULL, " - Stops the server cleanly");
-	PlgMgr->BindConsoleCommand("chunkstats", NULL, " - Displays detailed chunk memory statistics");
-	PlgMgr->BindConsoleCommand("load <pluginname>", NULL, " - Adds and enables the specified plugin");
-	PlgMgr->BindConsoleCommand("unload <pluginname>", NULL, " - Disables the specified plugin");
-	PlgMgr->BindConsoleCommand("destroyentities", NULL, " - Destroys all entities in all worlds");
+	PlgMgr->BindConsoleCommand("help", nullptr, " - Shows the available commands");
+	PlgMgr->BindConsoleCommand("reload", nullptr, " - Reloads all plugins");
+	PlgMgr->BindConsoleCommand("restart", nullptr, " - Restarts the server cleanly");
+	PlgMgr->BindConsoleCommand("stop", nullptr, " - Stops the server cleanly");
+	PlgMgr->BindConsoleCommand("chunkstats", nullptr, " - Displays detailed chunk memory statistics");
+	PlgMgr->BindConsoleCommand("load <pluginname>", nullptr, " - Adds and enables the specified plugin");
+	PlgMgr->BindConsoleCommand("unload <pluginname>", nullptr, " - Disables the specified plugin");
+	PlgMgr->BindConsoleCommand("destroyentities", nullptr, " - Destroys all entities in all worlds");
 
 	#if defined(_MSC_VER) && defined(_DEBUG) && defined(ENABLE_LEAK_FINDER)
-	PlgMgr->BindConsoleCommand("dumpmem", NULL, " - Dumps all used memory blocks together with their callstacks into memdump.xml");
+	PlgMgr->BindConsoleCommand("dumpmem", nullptr, " - Dumps all used memory blocks together with their callstacks into memdump.xml");
 	#endif
 }
 
@@ -710,7 +710,7 @@ void cServer::AuthenticateUser(int a_ClientID, const AString & a_Name, const ASt
 
 cServer::cNotifyWriteThread::cNotifyWriteThread(void) :
 	super("ClientPacketThread"),
-	m_Server(NULL)
+	m_Server(nullptr)
 {
 }
 
diff --git a/src/SetChunkData.cpp b/src/SetChunkData.cpp
index 707dfb9e8..e335176a8 100644
--- a/src/SetChunkData.cpp
+++ b/src/SetChunkData.cpp
@@ -42,15 +42,15 @@ cSetChunkData::cSetChunkData(
 	m_ShouldMarkDirty(a_ShouldMarkDirty)
 {
 	// Check the params' validity:
-	ASSERT(a_BlockTypes != NULL);
-	ASSERT(a_BlockMetas != NULL);
+	ASSERT(a_BlockTypes != nullptr);
+	ASSERT(a_BlockMetas != nullptr);
 
 	// Copy block types and metas:
 	memcpy(m_BlockTypes, a_BlockTypes, sizeof(cChunkDef::BlockTypes));
 	memcpy(m_BlockMetas, a_BlockMetas, sizeof(cChunkDef::BlockNibbles));
 	
 	// Copy lights, if both given:
-	if ((a_BlockLight != NULL) && (a_SkyLight != NULL))
+	if ((a_BlockLight != nullptr) && (a_SkyLight != nullptr))
 	{
 		memcpy(m_BlockLight, a_BlockLight, sizeof(m_BlockLight));
 		memcpy(m_SkyLight,   a_SkyLight,   sizeof(m_SkyLight));
@@ -62,7 +62,7 @@ cSetChunkData::cSetChunkData(
 	}
 	
 	// Copy the heightmap, if available:
-	if (a_HeightMap != NULL)
+	if (a_HeightMap != nullptr)
 	{
 		memcpy(m_HeightMap, a_HeightMap, sizeof(m_HeightMap));
 		m_IsHeightMapValid = true;
@@ -73,7 +73,7 @@ cSetChunkData::cSetChunkData(
 	}
 	
 	// Copy biomes, if available:
-	if (a_Biomes != NULL)
+	if (a_Biomes != nullptr)
 	{
 		memcpy(m_Biomes, a_Biomes, sizeof(m_Biomes));
 		m_AreBiomesValid = true;
diff --git a/src/SetChunkData.h b/src/SetChunkData.h
index 03e9ef4d9..1eeb75ca9 100644
--- a/src/SetChunkData.h
+++ b/src/SetChunkData.h
@@ -27,7 +27,7 @@ public:
 	Will move the entity and blockentity lists into the internal storage, and empty the a_Entities and
 	a_BlockEntities lists.
 	a_BlockTypes and a_BlockMetas must always be valid.
-	If either of the light arrays are NULL, the chunk data will be marked as not having any light at all and
+	If either of the light arrays are nullptr, the chunk data will be marked as not having any light at all and
 	will be scheduled for re-lighting once it is set into the chunkmap.
 	If a_Biomes is not valid, the internal flag is set and the world will calculate the biomes using the chunk
 	generator when setting the chunk data.
diff --git a/src/Simulator/DelayedFluidSimulator.cpp b/src/Simulator/DelayedFluidSimulator.cpp
index 59ea51aa0..dc8dffe2d 100644
--- a/src/Simulator/DelayedFluidSimulator.cpp
+++ b/src/Simulator/DelayedFluidSimulator.cpp
@@ -55,7 +55,7 @@ cDelayedFluidSimulatorChunkData::cDelayedFluidSimulatorChunkData(int a_TickDelay
 cDelayedFluidSimulatorChunkData::~cDelayedFluidSimulatorChunkData()
 {
 	delete[] m_Slots;
-	m_Slots = NULL;
+	m_Slots = nullptr;
 }
 
 
@@ -86,7 +86,7 @@ void cDelayedFluidSimulator::AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ,
 		return;
 	}
 	
-	if ((a_Chunk == NULL) || !a_Chunk->IsValid())
+	if ((a_Chunk == nullptr) || !a_Chunk->IsValid())
 	{
 		return;
 	}
diff --git a/src/Simulator/FireSimulator.cpp b/src/Simulator/FireSimulator.cpp
index d3deee74a..75ebefcf7 100644
--- a/src/Simulator/FireSimulator.cpp
+++ b/src/Simulator/FireSimulator.cpp
@@ -220,7 +220,7 @@ bool cFireSimulator::DoesBurnForever(BLOCKTYPE a_BlockType)
 
 void cFireSimulator::AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk)
 {
-	if ((a_Chunk == NULL) || !a_Chunk->IsValid())
+	if ((a_Chunk == nullptr) || !a_Chunk->IsValid())
 	{
 		return;
 	}
@@ -359,7 +359,7 @@ void cFireSimulator::RemoveFuelNeighbors(cChunk * a_Chunk, int a_RelX, int a_Rel
 		int Z = a_RelZ + gNeighborCoords[i].z;
 
 		cChunkPtr Neighbour = a_Chunk->GetRelNeighborChunkAdjustCoords(X, Z);
-		if (Neighbour == NULL)
+		if (Neighbour == nullptr)
 		{
 			continue;
 		}
diff --git a/src/Simulator/FloodyFluidSimulator.cpp b/src/Simulator/FloodyFluidSimulator.cpp
index b839aa746..e95ef216d 100644
--- a/src/Simulator/FloodyFluidSimulator.cpp
+++ b/src/Simulator/FloodyFluidSimulator.cpp
@@ -220,7 +220,7 @@ void cFloodyFluidSimulator::SpreadToNeighbor(cChunk * a_NearChunk, int a_RelX, i
 	ASSERT(a_NewMeta > 0);  // Source blocks aren't spread
 
 	a_NearChunk = a_NearChunk->GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
-	if ((a_NearChunk == NULL) || (!a_NearChunk->IsValid()))
+	if ((a_NearChunk == nullptr) || (!a_NearChunk->IsValid()))
 	{
 		// Chunk not available
 		return;
@@ -297,7 +297,7 @@ void cFloodyFluidSimulator::SpreadToNeighbor(cChunk * a_NearChunk, int a_RelX, i
 				ChunkInterface,
 				m_World,
 				PluginInterface,
-				NULL,
+				nullptr,
 				BlockX,
 				a_RelY,
 				BlockZ
diff --git a/src/Simulator/FluidSimulator.cpp b/src/Simulator/FluidSimulator.cpp
index 58501326f..9c8453d04 100644
--- a/src/Simulator/FluidSimulator.cpp
+++ b/src/Simulator/FluidSimulator.cpp
@@ -178,7 +178,7 @@ Direction cFluidSimulator::GetFlowingDirection(int a_X, int a_Y, int a_Z, bool a
 		
 		}
 		delete Pos;
-		Pos = NULL;
+		Pos = nullptr;
 	}
 
 	if (LowestPoint == m_World.GetBlockMeta(a_X, a_Y, a_Z))
diff --git a/src/Simulator/FluidSimulator.h b/src/Simulator/FluidSimulator.h
index 0877a7bf1..d65a8e78b 100644
--- a/src/Simulator/FluidSimulator.h
+++ b/src/Simulator/FluidSimulator.h
@@ -51,7 +51,7 @@ public:
 	virtual Direction GetFlowingDirection(int a_X, int a_Y, int a_Z, bool a_Over = true);
 	
 	/// Creates a ChunkData object for the simulator to use. The simulator returns the correct object type.
-	virtual cFluidSimulatorData * CreateChunkData(void) { return NULL; }
+	virtual cFluidSimulatorData * CreateChunkData(void) { return nullptr; }
 	
 	bool IsFluidBlock          (BLOCKTYPE a_BlockType) const { return (a_BlockType == m_FluidBlock); }
 	bool IsStationaryFluidBlock(BLOCKTYPE a_BlockType) const { return (a_BlockType == m_StationaryFluidBlock); }
diff --git a/src/Simulator/NoopRedstoneSimulator.h b/src/Simulator/NoopRedstoneSimulator.h
index 7c961f32b..832b26dfc 100644
--- a/src/Simulator/NoopRedstoneSimulator.h
+++ b/src/Simulator/NoopRedstoneSimulator.h
@@ -39,7 +39,7 @@ public:
 	
 	virtual cRedstoneSimulatorChunkData * CreateChunkData() override
 	{
-		return NULL;
+		return nullptr;
 	}
 
 } ;
diff --git a/src/Simulator/SandSimulator.cpp b/src/Simulator/SandSimulator.cpp
index aad41e463..073518b31 100644
--- a/src/Simulator/SandSimulator.cpp
+++ b/src/Simulator/SandSimulator.cpp
@@ -94,7 +94,7 @@ bool cSandSimulator::IsAllowedBlock(BLOCKTYPE a_BlockType)
 
 void cSandSimulator::AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk)
 {
-	if ((a_Chunk == NULL) || !a_Chunk->IsValid())
+	if ((a_Chunk == nullptr) || !a_Chunk->IsValid())
 	{
 		return;
 	}
diff --git a/src/Simulator/VaporizeFluidSimulator.cpp b/src/Simulator/VaporizeFluidSimulator.cpp
index 484cac334..119742346 100644
--- a/src/Simulator/VaporizeFluidSimulator.cpp
+++ b/src/Simulator/VaporizeFluidSimulator.cpp
@@ -22,7 +22,7 @@ cVaporizeFluidSimulator::cVaporizeFluidSimulator(cWorld & a_World, BLOCKTYPE a_F
 
 void cVaporizeFluidSimulator::AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk)
 {
-	if (a_Chunk == NULL)
+	if (a_Chunk == nullptr)
 	{
 		return;
 	}
diff --git a/src/StackWalker.h b/src/StackWalker.h
index bf47d3726..a609f6840 100644
--- a/src/StackWalker.h
+++ b/src/StackWalker.h
@@ -88,7 +88,7 @@ public:
 
   StackWalker(
     int options = OptionsAll, // 'int' is by design, to combine the enum-flags
-    LPCSTR szSymPath = NULL, 
+    LPCSTR szSymPath = nullptr, 
     DWORD dwProcessId = GetCurrentProcessId(), 
     HANDLE hProcess = GetCurrentProcess()
     );
@@ -108,9 +108,9 @@ public:
 
   BOOL ShowCallstack(
     HANDLE hThread = GetCurrentThread(), 
-    const CONTEXT *context = NULL, 
-    PReadProcessMemoryRoutine readMemoryFunction = NULL,
-    LPVOID pUserData = NULL  // optional to identify some data in the 'readMemoryFunction'-callback
+    const CONTEXT *context = nullptr, 
+    PReadProcessMemoryRoutine readMemoryFunction = nullptr,
+    LPVOID pUserData = nullptr  // optional to identify some data in the 'readMemoryFunction'-callback
     );
 
 #if _MSC_VER >= 1300
@@ -180,11 +180,11 @@ protected:
 #define GET_CURRENT_CONTEXT(c, contextFlags) \
   do { \
     memset(&c, 0, sizeof(CONTEXT)); \
-    EXCEPTION_POINTERS *pExp = NULL; \
+    EXCEPTION_POINTERS *pExp = nullptr; \
     __try { \
       throw 0; \
     } __except( ( (pExp = GetExceptionInformation()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_EXECUTE_HANDLER)) {} \
-    if (pExp != NULL) \
+    if (pExp != nullptr) \
       memcpy(&c, pExp->ContextRecord, sizeof(CONTEXT)); \
       c.ContextFlags = contextFlags; \
   } while(0);
diff --git a/src/StringUtils.cpp b/src/StringUtils.cpp
index 21962f832..34f2da682 100644
--- a/src/StringUtils.cpp
+++ b/src/StringUtils.cpp
@@ -20,7 +20,7 @@
 
 AString & AppendVPrintf(AString & str, const char * format, va_list args)
 {
-	ASSERT(format != NULL);
+	ASSERT(format != nullptr);
 	
 	char buffer[2048];
 	size_t len;
@@ -562,7 +562,7 @@ AString & CreateHexDump(AString & a_Out, const void * a_Data, size_t a_Size, siz
 		#else
 		int Count = sprintf(line, "%08x:", (unsigned)i);
 		#endif
-		// Remove the terminating NULL / leftover garbage in line, after the sprintf-ed value
+		// Remove the terminating nullptr / leftover garbage in line, after the sprintf-ed value
 		memset(line + Count, 32, sizeof(line) - Count);
 		p = line + 10;
 		q = p + 2 + a_BytesPerLine * 3 + 1;
diff --git a/src/UI/SlotArea.cpp b/src/UI/SlotArea.cpp
index 88d9f44fc..9113ec343 100644
--- a/src/UI/SlotArea.cpp
+++ b/src/UI/SlotArea.cpp
@@ -48,9 +48,9 @@ void cSlotArea::Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickA
 	ASSERT((a_SlotNum >= 0) && (a_SlotNum < GetNumSlots()));
 
 	bool bAsync = false;
-	if (GetSlot(a_SlotNum, a_Player) == NULL)
+	if (GetSlot(a_SlotNum, a_Player) == nullptr)
 	{
-		LOGWARNING("GetSlot(%d) returned NULL! Ignoring click", a_SlotNum);
+		LOGWARNING("GetSlot(%d) returned nullptr! Ignoring click", a_SlotNum);
 		return;
 	}
 	
@@ -791,9 +791,9 @@ void cSlotAreaAnvil::Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_C
 	}
 
 	bool bAsync = false;
-	if (GetSlot(a_SlotNum, a_Player) == NULL)
+	if (GetSlot(a_SlotNum, a_Player) == nullptr)
 	{
-		LOGWARNING("GetSlot(%d) returned NULL! Ignoring click", a_SlotNum);
+		LOGWARNING("GetSlot(%d) returned nullptr! Ignoring click", a_SlotNum);
 		return;
 	}
 
@@ -980,7 +980,7 @@ void cSlotAreaAnvil::OnTakeResult(cPlayer & a_Player)
 	m_ParentWindow.SetProperty(0, m_MaximumCost, a_Player);
 
 	m_MaximumCost = 0;
-	((cAnvilWindow*)&m_ParentWindow)->SetRepairedItemName("", NULL);
+	((cAnvilWindow*)&m_ParentWindow)->SetRepairedItemName("", nullptr);
 
 	int PosX, PosY, PosZ;
 	((cAnvilWindow*)&m_ParentWindow)->GetBlockPos(PosX, PosY, PosZ);
@@ -1238,9 +1238,9 @@ void cSlotAreaBeacon::Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_
 	ASSERT((a_SlotNum >= 0) && (a_SlotNum < GetNumSlots()));
 
 	bool bAsync = false;
-	if (GetSlot(a_SlotNum, a_Player) == NULL)
+	if (GetSlot(a_SlotNum, a_Player) == nullptr)
 	{
-		LOGWARNING("GetSlot(%d) returned NULL! Ignoring click", a_SlotNum);
+		LOGWARNING("GetSlot(%d) returned nullptr! Ignoring click", a_SlotNum);
 		return;
 	}
 
@@ -1408,9 +1408,9 @@ void cSlotAreaEnchanting::Clicked(cPlayer & a_Player, int a_SlotNum, eClickActio
 	ASSERT((a_SlotNum >= 0) && (a_SlotNum < GetNumSlots()));
 
 	bool bAsync = false;
-	if (GetSlot(a_SlotNum, a_Player) == NULL)
+	if (GetSlot(a_SlotNum, a_Player) == nullptr)
 	{
-		LOGWARNING("GetSlot(%d) returned NULL! Ignoring click", a_SlotNum);
+		LOGWARNING("GetSlot(%d) returned nullptr! Ignoring click", a_SlotNum);
 		return;
 	}
 
@@ -1709,19 +1709,19 @@ cSlotAreaFurnace::~cSlotAreaFurnace()
 
 void cSlotAreaFurnace::Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem)
 {
-	if (m_Furnace == NULL)
+	if (m_Furnace == nullptr)
 	{
-		LOGERROR("cSlotAreaFurnace::Clicked(): m_Furnace == NULL");
-		ASSERT(!"cSlotAreaFurnace::Clicked(): m_Furnace == NULL");
+		LOGERROR("cSlotAreaFurnace::Clicked(): m_Furnace == nullptr");
+		ASSERT(!"cSlotAreaFurnace::Clicked(): m_Furnace == nullptr");
 		return;
 	}
 
 	if (a_SlotNum == 2)
 	{
 		bool bAsync = false;
-		if (GetSlot(a_SlotNum, a_Player) == NULL)
+		if (GetSlot(a_SlotNum, a_Player) == nullptr)
 		{
-			LOGWARNING("GetSlot(%d) returned NULL! Ignoring click", a_SlotNum);
+			LOGWARNING("GetSlot(%d) returned nullptr! Ignoring click", a_SlotNum);
 			return;
 		}
 
@@ -2071,9 +2071,9 @@ void cSlotAreaArmor::Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_C
 	}
 
 	bool bAsync = false;
-	if (GetSlot(a_SlotNum, a_Player) == NULL)
+	if (GetSlot(a_SlotNum, a_Player) == nullptr)
 	{
-		LOGWARNING("GetSlot(%d) returned NULL! Ignoring click", a_SlotNum);
+		LOGWARNING("GetSlot(%d) returned nullptr! Ignoring click", a_SlotNum);
 		return;
 	}
 
@@ -2223,15 +2223,15 @@ const cItem * cSlotAreaTemporary::GetSlot(int a_SlotNum, cPlayer & a_Player) con
 		LOGERROR("cSlotAreaTemporary: player \"%s\" not found for slot %d!", a_Player.GetName().c_str(), a_SlotNum);
 		ASSERT(!"cSlotAreaTemporary: player not found!");
 		
-		// Player not found, this should not happen, ever! Return NULL, but things may break by this.
-		return NULL;
+		// Player not found, this should not happen, ever! Return nullptr, but things may break by this.
+		return nullptr;
 	}
 	
 	if (a_SlotNum >= (int)(itr->second.size()))
 	{
 		LOGERROR("cSlotAreaTemporary: asking for more slots than actually stored!");
 		ASSERT(!"cSlotAreaTemporary: asking for more slots than actually stored!");
-		return NULL;
+		return nullptr;
 	}
 	
 	return &(itr->second[a_SlotNum]);
@@ -2320,7 +2320,7 @@ cItem * cSlotAreaTemporary::GetPlayerSlots(cPlayer & a_Player)
 	cItemMap::iterator itr = m_Items.find(a_Player.GetUniqueID());
 	if (itr == m_Items.end())
 	{
-		return NULL;
+		return nullptr;
 	}
 	return &(itr->second[0]);
 }
diff --git a/src/UI/Window.cpp b/src/UI/Window.cpp
index 802d0d219..1598dd3e7 100644
--- a/src/UI/Window.cpp
+++ b/src/UI/Window.cpp
@@ -33,7 +33,7 @@ cWindow::cWindow(WindowType a_WindowType, const AString & a_WindowTitle) :
 	m_WindowTitle(a_WindowTitle),
 	m_IsDestroyed(false),
 	m_ShouldDistributeToHotbarFirst(true),
-	m_Owner(NULL)
+	m_Owner(nullptr)
 {
 	if (a_WindowType == wtInventory)
 	{
@@ -105,10 +105,10 @@ const cItem * cWindow::GetSlot(cPlayer & a_Player, int a_SlotNum) const
 	// Return the item at the specified slot for the specified player
 	int LocalSlotNum = 0;
 	const cSlotArea * Area = GetSlotArea(a_SlotNum, LocalSlotNum);
-	if (Area == NULL)
+	if (Area == nullptr)
 	{
-		LOGWARNING("%s: requesting item from an invalid SlotArea (SlotNum %d), returning NULL.", __FUNCTION__, a_SlotNum);
-		return NULL;
+		LOGWARNING("%s: requesting item from an invalid SlotArea (SlotNum %d), returning nullptr.", __FUNCTION__, a_SlotNum);
+		return nullptr;
 	}
 	return Area->GetSlot(LocalSlotNum, a_Player);
 }
@@ -122,7 +122,7 @@ void cWindow::SetSlot(cPlayer & a_Player, int a_SlotNum, const cItem & a_Item)
 	// Set the item to the specified slot for the specified player
 	int LocalSlotNum = 0;
 	cSlotArea * Area = GetSlotArea(a_SlotNum, LocalSlotNum);
-	if (Area == NULL)
+	if (Area == nullptr)
 	{
 		LOGWARNING("%s: requesting write to an invalid SlotArea (SlotNum %d), ignoring.", __FUNCTION__, a_SlotNum);
 		return;
@@ -177,7 +177,7 @@ void cWindow::GetSlots(cPlayer & a_Player, cItems & a_Slots) const
 		for (int i = 0; i < NumSlots; i++)
 		{
 			const cItem * Item = (*itr)->GetSlot(i, a_Player);
-			if (Item == NULL)
+			if (Item == nullptr)
 			{
 				a_Slots.push_back(cItem());
 			}
@@ -311,7 +311,7 @@ bool cWindow::ClosedByPlayer(cPlayer & a_Player, bool a_CanRefuse)
 	}
 
 	cClientHandle * ClientHandle = a_Player.GetClientHandle();
-	if (ClientHandle != NULL)
+	if (ClientHandle != nullptr)
 	{
 		ClientHandle->SendWindowClose(*this);
 	}
@@ -345,7 +345,7 @@ bool cWindow::ClosedByPlayer(cPlayer & a_Player, bool a_CanRefuse)
 
 void cWindow::OwnerDestroyed()
 {
-	m_Owner = NULL;
+	m_Owner = nullptr;
 	// Close window for each player. Note that the last one needs special handling
 	while (m_OpenedBy.size() > 1)
 	{
@@ -511,10 +511,10 @@ void cWindow::SendSlot(cPlayer & a_Player, cSlotArea * a_SlotArea, int a_Relativ
 
 void cWindow::Destroy(void)
 {
-	if (m_Owner != NULL)
+	if (m_Owner != nullptr)
 	{
 		m_Owner->CloseWindow();
-		m_Owner = NULL;
+		m_Owner = nullptr;
 	}
 	m_IsDestroyed = true;
 }
@@ -529,7 +529,7 @@ cSlotArea * cWindow::GetSlotArea(int a_GlobalSlotNum, int & a_LocalSlotNum)
 	{
 		LOGWARNING("%s: requesting an invalid SlotNum: %d out of %d slots", __FUNCTION__, a_GlobalSlotNum, GetNumSlots() - 1);
 		ASSERT(!"Invalid SlotNum");
-		return NULL;
+		return nullptr;
 	}
 	
 	// Iterate through all the SlotAreas, find the correct one
@@ -547,7 +547,7 @@ cSlotArea * cWindow::GetSlotArea(int a_GlobalSlotNum, int & a_LocalSlotNum)
 	// We shouldn't be here - the check at the beginnning should prevent this. Log and assert
 	LOGWARNING("%s: GetNumSlots() is out of sync: %d; LocalSlotNum = %d", __FUNCTION__, GetNumSlots(), LocalSlotNum);
 	ASSERT(!"Invalid GetNumSlots");
-	return NULL;
+	return nullptr;
 }
 
 
@@ -560,7 +560,7 @@ const cSlotArea * cWindow::GetSlotArea(int a_GlobalSlotNum, int & a_LocalSlotNum
 	{
 		LOGWARNING("%s: requesting an invalid SlotNum: %d out of %d slots", __FUNCTION__, a_GlobalSlotNum, GetNumSlots() - 1);
 		ASSERT(!"Invalid SlotNum");
-		return NULL;
+		return nullptr;
 	}
 	
 	// Iterate through all the SlotAreas, find the correct one
@@ -578,7 +578,7 @@ const cSlotArea * cWindow::GetSlotArea(int a_GlobalSlotNum, int & a_LocalSlotNum
 	// We shouldn't be here - the check at the beginnning should prevent this. Log and assert
 	LOGWARNING("%s: GetNumSlots() is out of sync: %d; LocalSlotNum = %d", __FUNCTION__, GetNumSlots(), LocalSlotNum);
 	ASSERT(!"Invalid GetNumSlots");
-	return NULL;
+	return nullptr;
 }
 
 
@@ -669,7 +669,7 @@ int cWindow::DistributeItemToSlots(cPlayer & a_Player, const cItem & a_Item, int
 	{
 		int LocalSlotNum = 0;
 		cSlotArea * Area = GetSlotArea(*itr, LocalSlotNum);
-		if (Area == NULL)
+		if (Area == nullptr)
 		{
 			LOGWARNING("%s: Bad SlotArea for slot %d", __FUNCTION__, *itr);
 			continue;
@@ -836,7 +836,7 @@ void cAnvilWindow::SetRepairedItemName(const AString & a_Name, cPlayer * a_Playe
 {
 	m_RepairedItemName = a_Name;
 
-	if (a_Player != NULL)
+	if (a_Player != nullptr)
 	{
 		m_AnvilSlotArea->UpdateResult(*a_Player);
 	}
@@ -963,7 +963,7 @@ cChestWindow::cChestWindow(cChestEntity * a_Chest) :
 	m_BlockY(a_Chest->GetPosY()),
 	m_BlockZ(a_Chest->GetPosZ()),
 	m_PrimaryChest(a_Chest),
-	m_SecondaryChest(NULL)
+	m_SecondaryChest(nullptr)
 {
 	m_SlotAreas.push_back(new cSlotAreaChest(a_Chest, *this));
 	m_SlotAreas.push_back(new cSlotAreaInventory(*this));
@@ -1014,7 +1014,7 @@ void cChestWindow::OpenedByPlayer(cPlayer & a_Player)
 	cChunkDef::BlockToChunk(m_PrimaryChest->GetPosX(), m_PrimaryChest->GetPosZ(), ChunkX, ChunkZ);
 	m_PrimaryChest->GetWorld()->MarkRedstoneDirty(ChunkX, ChunkZ);
 
-	if (m_SecondaryChest != NULL)
+	if (m_SecondaryChest != nullptr)
 	{
 		m_SecondaryChest->SetNumberOfPlayers(m_SecondaryChest->GetNumberOfPlayers() + 1);
 		cChunkDef::BlockToChunk(m_SecondaryChest->GetPosX(), m_SecondaryChest->GetPosZ(), ChunkX, ChunkZ);
@@ -1036,7 +1036,7 @@ bool cChestWindow::ClosedByPlayer(cPlayer & a_Player, bool a_CanRefuse)
 	cChunkDef::BlockToChunk(m_PrimaryChest->GetPosX(), m_PrimaryChest->GetPosZ(), ChunkX, ChunkZ);
 	m_PrimaryChest->GetWorld()->MarkRedstoneDirty(ChunkX, ChunkZ);
 
-	if (m_SecondaryChest != NULL)
+	if (m_SecondaryChest != nullptr)
 	{
 		m_SecondaryChest->SetNumberOfPlayers(m_SecondaryChest->GetNumberOfPlayers() - 1);
 		cChunkDef::BlockToChunk(m_SecondaryChest->GetPosX(), m_SecondaryChest->GetPosZ(), ChunkX, ChunkZ);
diff --git a/src/UI/Window.h b/src/UI/Window.h
index 26dd7f125..e62176d50 100644
--- a/src/UI/Window.h
+++ b/src/UI/Window.h
@@ -90,7 +90,7 @@ public:
 	
 	// tolua_begin
 	
-	/// Returns the item at the specified slot for the specified player. Returns NULL if invalid SlotNum requested
+	/// Returns the item at the specified slot for the specified player. Returns nullptr if invalid SlotNum requested
 	const cItem * GetSlot(cPlayer & a_Player, int a_SlotNum) const;
 	
 	/// Sets the item to the specified slot for the specified player
@@ -189,13 +189,13 @@ protected:
 	
 	/** Returns the correct slot area for the specified window-global SlotNum
 	Also returns the area-local SlotNum corresponding to the GlobalSlotNum
-	If the global SlotNum is out of range, returns NULL
+	If the global SlotNum is out of range, returns nullptr
 	*/
 	cSlotArea * GetSlotArea(int a_GlobalSlotNum, int & a_LocalSlotNum);
 	
 	/** Returns the correct slot area for the specified window-global SlotNum
 	Also returns the area-local SlotNum corresponding to the GlobalSlotNum
-	If the global SlotNum is out of range, returns NULL.
+	If the global SlotNum is out of range, returns nullptr.
 	Const version.
 	*/
 	const cSlotArea * GetSlotArea(int a_GlobalSlotNum, int & a_LocalSlotNum) const;
diff --git a/src/UI/WindowOwner.h b/src/UI/WindowOwner.h
index 6845a161b..4dc3cf080 100644
--- a/src/UI/WindowOwner.h
+++ b/src/UI/WindowOwner.h
@@ -22,7 +22,7 @@ class cWindowOwner
 {
 public:
 	cWindowOwner() :
-		m_Window(NULL)
+		m_Window(nullptr)
 	{
 	}
 
@@ -32,7 +32,7 @@ public:
 
 	void CloseWindow(void)
 	{
-		m_Window = NULL;
+		m_Window = nullptr;
 	}
 
 	void OpenWindow(cWindow * a_Window)
diff --git a/src/WebAdmin.cpp b/src/WebAdmin.cpp
index db2ace386..dbf600c25 100644
--- a/src/WebAdmin.cpp
+++ b/src/WebAdmin.cpp
@@ -224,7 +224,7 @@ void cWebAdmin::HandleWebadminRequest(cHTTPConnection & a_Connection, cHTTPReque
 
 	// Retrieve the request data:
 	cWebadminRequestData * Data = (cWebadminRequestData *)(a_Request.GetUserData());
-	if (Data == NULL)
+	if (Data == nullptr)
 	{
 		a_Connection.SendStatusAndReason(500, "Bad UserData");
 		return;
@@ -483,7 +483,7 @@ AString cWebAdmin::GetDefaultPage(void)
 	const cPluginManager::PluginMap & List = PM->GetAllPlugins();
 	for (cPluginManager::PluginMap::const_iterator itr = List.begin(); itr != List.end(); ++itr)
 	{
-		if (itr->second == NULL)
+		if (itr->second == nullptr)
 		{
 			continue;
 		}
@@ -494,7 +494,7 @@ AString cWebAdmin::GetDefaultPage(void)
 
 	cPlayerAccum PlayerAccum;
 	cWorld * World = cRoot::Get()->GetDefaultWorld();  // TODO - Create a list of worlds and players
-	if (World != NULL)
+	if (World != nullptr)
 	{
 		World->ForEachPlayer(PlayerAccum);
 		Content.append(PlayerAccum.m_Contents);
@@ -625,7 +625,7 @@ void cWebAdmin::OnRequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_R
 {
 	UNUSED(a_Connection);
 	cRequestData * Data = (cRequestData *)(a_Request.GetUserData());
-	if (Data == NULL)
+	if (Data == nullptr)
 	{
 		return;
 	}
@@ -659,7 +659,7 @@ void cWebAdmin::OnRequestFinished(cHTTPConnection & a_Connection, cHTTPRequest &
 	// Delete any request data assigned to the request:
 	cRequestData * Data = (cRequestData *)(a_Request.GetUserData());
 	delete Data;
-	Data = NULL;
+	Data = nullptr;
 }
 
 
diff --git a/src/World.cpp b/src/World.cpp
index 010fc0d87..c6168b572 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -252,10 +252,10 @@ cWorld::cWorld(const AString & a_WorldName, eDimension a_Dimension, const AStrin
 	m_VillagersShouldHarvestCrops(true),
 	m_SimulatorManager(),
 	m_SandSimulator(),
-	m_WaterSimulator(NULL),
+	m_WaterSimulator(nullptr),
 	m_LavaSimulator(nullptr),
 	m_FireSimulator(),
-	m_RedstoneSimulator(NULL),
+	m_RedstoneSimulator(nullptr),
 	m_MaxPlayers(10),
 	m_ChunkMap(),
 	m_bAnimals(true),
@@ -297,9 +297,9 @@ cWorld::cWorld(const AString & a_WorldName, eDimension a_Dimension, const AStrin
 
 cWorld::~cWorld()
 {
-	delete m_WaterSimulator;     m_WaterSimulator    = NULL;
-	delete m_LavaSimulator;      m_LavaSimulator     = NULL;
-	delete m_RedstoneSimulator;  m_RedstoneSimulator = NULL;
+	delete m_WaterSimulator;     m_WaterSimulator    = nullptr;
+	delete m_LavaSimulator;      m_LavaSimulator     = nullptr;
+	delete m_RedstoneSimulator;  m_RedstoneSimulator = nullptr;
 
 	UnloadUnusedChunks();
 	
@@ -1255,7 +1255,7 @@ void cWorld::DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_Blo
 		for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 		{
 			cClientHandle * ch = (*itr)->GetClientHandle();
-			if (ch == NULL)
+			if (ch == nullptr)
 			{
 				continue;
 			}
@@ -2010,7 +2010,7 @@ void cWorld::BroadcastChat(const AString & a_Message, const cClientHandle * a_Ex
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == a_Exclude) || (ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2028,7 +2028,7 @@ void cWorld::BroadcastChat(const cCompositeChat & a_Message, const cClientHandle
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == a_Exclude) || (ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2171,7 +2171,7 @@ void cWorld::BroadcastPlayerListAddPlayer(const cPlayer & a_Player, const cClien
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == a_Exclude) || (ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2189,7 +2189,7 @@ void cWorld::BroadcastPlayerListRemovePlayer(const cPlayer & a_Player, const cCl
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == a_Exclude) || (ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2207,7 +2207,7 @@ void cWorld::BroadcastPlayerListUpdateGameMode(const cPlayer & a_Player, const c
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == a_Exclude) || (ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2225,7 +2225,7 @@ void cWorld::BroadcastPlayerListUpdatePing(const cPlayer & a_Player, const cClie
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == a_Exclude) || (ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2243,7 +2243,7 @@ void cWorld::BroadcastPlayerListUpdateDisplayName(const cPlayer & a_Player, cons
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == a_Exclude) || (ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2270,7 +2270,7 @@ void cWorld::BroadcastScoreboardObjective(const AString & a_Name, const AString
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2288,7 +2288,7 @@ void cWorld::BroadcastScoreUpdate(const AString & a_Objective, const AString & a
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2306,7 +2306,7 @@ void cWorld::BroadcastDisplayObjective(const AString & a_Objective, cScoreboard:
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2351,7 +2351,7 @@ void cWorld::BroadcastTeleportEntity(const cEntity & a_Entity, const cClientHand
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == a_Exclude) || (ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2378,7 +2378,7 @@ void cWorld::BroadcastTimeUpdate(const cClientHandle * a_Exclude)
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == a_Exclude) || (ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2405,7 +2405,7 @@ void cWorld::BroadcastWeather(eWeather a_Weather, const cClientHandle * a_Exclud
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		if ((ch == a_Exclude) || (ch == nullptr) || !ch->IsLoggedIn() || ch->IsDestroyed())
 		{
 			continue;
 		}
@@ -2640,7 +2640,7 @@ void cWorld::RemovePlayer(cPlayer * a_Player, bool a_RemoveFromChunk)
 	
 	// Remove the player's client from the list of clients to be ticked:
 	cClientHandle * Client = a_Player->GetClientHandle();
-	if (Client != NULL)
+	if (Client != nullptr)
 	{
 		Client->RemoveFromWorld();
 		m_ChunkMap->RemoveClientFromChunks(Client);
@@ -2693,7 +2693,7 @@ bool cWorld::DoWithPlayer(const AString & a_PlayerName, cPlayerListCallback & a_
 
 bool cWorld::FindAndDoWithPlayer(const AString & a_PlayerNameHint, cPlayerListCallback & a_Callback)
 {
-	cPlayer * BestMatch = NULL;
+	cPlayer * BestMatch = nullptr;
 	size_t BestRating = 0;
 	size_t NameLength = a_PlayerNameHint.length();
 
@@ -2712,7 +2712,7 @@ bool cWorld::FindAndDoWithPlayer(const AString & a_PlayerNameHint, cPlayerListCa
 		}
 	}  // for itr - m_Players[]
 
-	if (BestMatch != NULL)
+	if (BestMatch != nullptr)
 	{
 		return a_Callback.Item (BestMatch);
 	}
@@ -2729,7 +2729,7 @@ cPlayer * cWorld::FindClosestPlayer(const Vector3d & a_Pos, float a_SightLimit,
 	cTracer LineOfSight(this);
 
 	double ClosestDistance = a_SightLimit;
-	cPlayer * ClosestPlayer = NULL;
+	cPlayer * ClosestPlayer = nullptr;
 
 	cCSLock Lock(m_CSPlayers);
 	for (cPlayerList::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
@@ -2768,7 +2768,7 @@ void cWorld::SendPlayerList(cPlayer * a_DestPlayer)
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		cClientHandle * ch = (*itr)->GetClientHandle();
-		if ((ch != NULL) && !ch->IsDestroyed())
+		if ((ch != nullptr) && !ch->IsDestroyed())
 		{
 			a_DestPlayer->GetClientHandle()->SendPlayerListAddPlayer(*(*itr));
 		}
@@ -3212,10 +3212,10 @@ bool cWorld::IsBlockDirectlyWatered(int a_BlockX, int a_BlockY, int a_BlockZ)
 
 int cWorld::SpawnMob(double a_PosX, double a_PosY, double a_PosZ, eMonsterType a_MonsterType)
 {
-	cMonster * Monster = NULL;
+	cMonster * Monster = nullptr;
 
 	Monster = cMonster::NewMonsterFromType(a_MonsterType);
-	if (Monster != NULL)
+	if (Monster != nullptr)
 	{
 		Monster->SetPosition(a_PosX, a_PosY, a_PosZ);
 	}
@@ -3241,7 +3241,7 @@ int cWorld::SpawnMobFinalize(cMonster * a_Monster)
 	if (cPluginManager::Get()->CallHookSpawningMonster(*this, *a_Monster))
 	{
 		delete a_Monster;
-		a_Monster = NULL;
+		a_Monster = nullptr;
 		return -1;
 	}
 
@@ -3249,7 +3249,7 @@ int cWorld::SpawnMobFinalize(cMonster * a_Monster)
 	if (!a_Monster->Initialize(*this))
 	{
 		delete a_Monster;
-		a_Monster = NULL;
+		a_Monster = nullptr;
 		return -1;
 	}
 
@@ -3266,14 +3266,14 @@ int cWorld::SpawnMobFinalize(cMonster * a_Monster)
 int cWorld::CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const cItem * a_Item, const Vector3d * a_Speed)
 {
 	cProjectileEntity * Projectile = cProjectileEntity::Create(a_Kind, a_Creator, a_PosX, a_PosY, a_PosZ, a_Item, a_Speed);
-	if (Projectile == NULL)
+	if (Projectile == nullptr)
 	{
 		return -1;
 	}
 	if (!Projectile->Initialize(*this))
 	{
 		delete Projectile;
-		Projectile = NULL;
+		Projectile = nullptr;
 		return -1;
 	}
 	return Projectile->GetUniqueID();
@@ -3356,7 +3356,7 @@ cRedstoneSimulator<cChunk, cWorld> * cWorld::InitializeRedstoneSimulator(cIniFil
 		SimulatorName = "Incremental";
 	}
 	
-	cRedstoneSimulator<cChunk, cWorld> * res = NULL;
+	cRedstoneSimulator<cChunk, cWorld> * res = nullptr;
 
 	if (NoCaseCompare(SimulatorName, "Incremental") == 0)
 	{
@@ -3389,7 +3389,7 @@ cFluidSimulator * cWorld::InitializeFluidSimulator(cIniFile & a_IniFile, const c
 		SimulatorName = "Vanilla";
 	}
 	
-	cFluidSimulator * res = NULL;
+	cFluidSimulator * res = nullptr;
 	bool IsWater = (strcmp(a_FluidName, "Water") == 0);  // Used for defaults
 	int Rate = 1;
 	if (
@@ -3479,7 +3479,7 @@ void cWorld::AddQueuedPlayers(void)
 		for (cPlayerList::iterator itr = PlayersToAdd.begin(), end = PlayersToAdd.end(); itr != end; ++itr)
 		{
 			cClientHandle * Client = (*itr)->GetClientHandle();
-			if (Client != NULL)
+			if (Client != nullptr)
 			{
 				m_Clients.push_back(Client);
 			}
@@ -3490,7 +3490,7 @@ void cWorld::AddQueuedPlayers(void)
 	for (cPlayerList::iterator itr = PlayersToAdd.begin(), end = PlayersToAdd.end(); itr != end; ++itr)
 	{
 		cClientHandle * Client = (*itr)->GetClientHandle();
-		if (Client != NULL)
+		if (Client != nullptr)
 		{
 			Client->StreamChunks();
 			Client->SendPlayerMoveLook();
@@ -3591,7 +3591,7 @@ void cWorld::cChunkGeneratorCallbacks::OnChunkGenerated(cChunkDesc & a_ChunkDesc
 	cSetChunkDataPtr SetChunkData(new cSetChunkData(
 		a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ(),
 		a_ChunkDesc.GetBlockTypes(), BlockMetas,
-		NULL, NULL,  // We don't have lighting, chunk will be lighted when needed
+		nullptr, nullptr,  // We don't have lighting, chunk will be lighted when needed
 		&a_ChunkDesc.GetHeightMap(), &a_ChunkDesc.GetBiomeMap(),
 		a_ChunkDesc.GetEntities(), a_ChunkDesc.GetBlockEntities(),
 		true
diff --git a/src/World.h b/src/World.h
index 338721553..b1b80ffb2 100644
--- a/src/World.h
+++ b/src/World.h
@@ -212,52 +212,52 @@ public:
 	// Broadcast respective packets to all clients of the chunk where the event is taking place
 	// (Please keep these alpha-sorted)
 	void BroadcastAttachEntity       (const cEntity & a_Entity, const cEntity * a_Vehicle);
-	void BroadcastBlockAction        (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType, const cClientHandle * a_Exclude = NULL);  // tolua_export
-	void BroadcastBlockBreakAnimation(int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage, const cClientHandle * a_Exclude = NULL);
-	void BroadcastBlockEntity        (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);  ///< If there is a block entity at the specified coods, sends it to all clients except a_Exclude
+	void BroadcastBlockAction        (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType, const cClientHandle * a_Exclude = nullptr);  // tolua_export
+	void BroadcastBlockBreakAnimation(int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastBlockEntity        (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = nullptr);  ///< If there is a block entity at the specified coods, sends it to all clients except a_Exclude
 
 	// tolua_begin
-	void BroadcastChat       (const AString & a_Message, const cClientHandle * a_Exclude = NULL, eMessageType a_ChatPrefix = mtCustom);
-	void BroadcastChatInfo   (const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtInformation); }
-	void BroadcastChatFailure(const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtFailure); }
-	void BroadcastChatSuccess(const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtSuccess); }
-	void BroadcastChatWarning(const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtWarning); }
-	void BroadcastChatFatal  (const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtFailure); }
-	void BroadcastChatDeath  (const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtDeath); }
-	void BroadcastChat       (const cCompositeChat & a_Message, const cClientHandle * a_Exclude = NULL);
+	void BroadcastChat       (const AString & a_Message, const cClientHandle * a_Exclude = nullptr, eMessageType a_ChatPrefix = mtCustom);
+	void BroadcastChatInfo   (const AString & a_Message, const cClientHandle * a_Exclude = nullptr) { BroadcastChat(a_Message, a_Exclude, mtInformation); }
+	void BroadcastChatFailure(const AString & a_Message, const cClientHandle * a_Exclude = nullptr) { BroadcastChat(a_Message, a_Exclude, mtFailure); }
+	void BroadcastChatSuccess(const AString & a_Message, const cClientHandle * a_Exclude = nullptr) { BroadcastChat(a_Message, a_Exclude, mtSuccess); }
+	void BroadcastChatWarning(const AString & a_Message, const cClientHandle * a_Exclude = nullptr) { BroadcastChat(a_Message, a_Exclude, mtWarning); }
+	void BroadcastChatFatal  (const AString & a_Message, const cClientHandle * a_Exclude = nullptr) { BroadcastChat(a_Message, a_Exclude, mtFailure); }
+	void BroadcastChatDeath  (const AString & a_Message, const cClientHandle * a_Exclude = nullptr) { BroadcastChat(a_Message, a_Exclude, mtDeath); }
+	void BroadcastChat       (const cCompositeChat & a_Message, const cClientHandle * a_Exclude = nullptr);
 	// tolua_end
 
-	void BroadcastChunkData                  (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = NULL);
-	void BroadcastCollectEntity              (const cEntity & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastDestroyEntity              (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityHeadLook             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityLook                 (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityMetadata             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMove              (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMoveLook          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityStatus               (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityVelocity             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	virtual void BroadcastEntityAnimation    (const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL) override;  // tolua_export
-	void BroadcastParticleEffect             (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude = NULL);  // tolua_export
-	void BroadcastPlayerListAddPlayer        (const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastPlayerListRemovePlayer     (const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastPlayerListUpdateGameMode   (const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastPlayerListUpdatePing       (const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName, const cClientHandle * a_Exclude = NULL);
-	void BroadcastRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
+	void BroadcastChunkData                  (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastCollectEntity              (const cEntity & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastDestroyEntity              (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityHeadLook             (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityLook                 (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityMetadata             (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityRelMove              (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityRelMoveLook          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityStatus               (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastEntityVelocity             (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	virtual void BroadcastEntityAnimation    (const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = nullptr) override;  // tolua_export
+	void BroadcastParticleEffect             (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude = nullptr);  // tolua_export
+	void BroadcastPlayerListAddPlayer        (const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastPlayerListRemovePlayer     (const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastPlayerListUpdateGameMode   (const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastPlayerListUpdatePing       (const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastScoreboardObjective        (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode);
 	void BroadcastScoreUpdate                (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode);
 	void BroadcastDisplayObjective           (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display);
-	void BroadcastSoundEffect                (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);   // tolua_export
-	void BroadcastSoundParticleEffect        (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL);  // tolua_export
-	void BroadcastSpawnEntity                (cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastTeleportEntity             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastThunderbolt                (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastTimeUpdate                 (const cClientHandle * a_Exclude = NULL);
+	void BroadcastSoundEffect                (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = nullptr);   // tolua_export
+	void BroadcastSoundParticleEffect        (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = nullptr);  // tolua_export
+	void BroadcastSpawnEntity                (cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastTeleportEntity             (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastThunderbolt                (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = nullptr);
+	void BroadcastTimeUpdate                 (const cClientHandle * a_Exclude = nullptr);
 	virtual void BroadcastUseBed             (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
-	void BroadcastWeather                    (eWeather a_Weather, const cClientHandle * a_Exclude = NULL);
+	void BroadcastWeather                    (eWeather a_Weather, const cClientHandle * a_Exclude = nullptr);
 	
 	virtual cBroadcastInterface & GetBroadcastManager(void) override
 	{
@@ -374,11 +374,11 @@ public:
 	/** Marks the chunk as failed-to-load: */
 	void ChunkLoadFailed(int a_ChunkX, int a_ChunkZ);
 	
-	/** Sets the sign text, asking plugins for permission first. a_Player is the player who this change belongs to, may be NULL. Returns true if sign text changed. Same as UpdateSign() */
-	bool SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4, cPlayer * a_Player = NULL);  // Exported in ManualBindings.cpp
+	/** Sets the sign text, asking plugins for permission first. a_Player is the player who this change belongs to, may be nullptr. Returns true if sign text changed. Same as UpdateSign() */
+	bool SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4, cPlayer * a_Player = nullptr);  // Exported in ManualBindings.cpp
 	
-	/** Sets the sign text, asking plugins for permission first. a_Player is the player who this change belongs to, may be NULL. Returns true if sign text changed. Same as SetSignLines() */
-	bool UpdateSign(int a_X, int a_Y, int a_Z, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4, cPlayer * a_Player = NULL);  // Exported in ManualBindings.cpp
+	/** Sets the sign text, asking plugins for permission first. a_Player is the player who this change belongs to, may be nullptr. Returns true if sign text changed. Same as SetSignLines() */
+	bool UpdateSign(int a_X, int a_Y, int a_Z, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4, cPlayer * a_Player = nullptr);  // Exported in ManualBindings.cpp
 
 	/** Sets the command block command. Returns true if command changed. */
 	bool SetCommandBlockCommand(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Command);  // tolua_export
@@ -396,7 +396,7 @@ public:
 	void GenerateChunk(int a_ChunkX, int a_ChunkZ);  // tolua_export
 	
 	/** Queues a chunk for lighting; a_Callback is called after the chunk is lighted */
-	void QueueLightChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_Callback = NULL);
+	void QueueLightChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_Callback = nullptr);
 	
 	bool IsChunkLighted(int a_ChunkX, int a_ChunkZ);
 	
@@ -781,7 +781,7 @@ public:
 	/** Creates a projectile of the specified type. Returns the projectile's EntityID if successful, <0 otherwise
 	Item parameter used currently for Fireworks to correctly set entity metadata based on item metadata
 	*/
-	int CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const cItem * a_Item, const Vector3d * a_Speed = NULL);  // tolua_export
+	int CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const cItem * a_Item, const Vector3d * a_Speed = nullptr);  // tolua_export
 	
 	/** Returns a random number from the m_TickRand in range [0 .. a_Range]. To be used only in the tick thread! */
 	int GetTickRandomNumber(unsigned a_Range) { return (int)(m_TickRand.randInt(a_Range)); }
@@ -857,7 +857,7 @@ private:
 		virtual ~cScheduledTask()
 		{
 			delete m_Task;
-			m_Task = NULL;
+			m_Task = nullptr;
 		}
 	};
 
diff --git a/src/WorldStorage/NBTChunkSerializer.cpp b/src/WorldStorage/NBTChunkSerializer.cpp
index 28b9dd042..c4862bdb4 100644
--- a/src/WorldStorage/NBTChunkSerializer.cpp
+++ b/src/WorldStorage/NBTChunkSerializer.cpp
@@ -467,7 +467,7 @@ void cNBTChunkSerializer::AddMinecartEntity(cMinecart * a_Minecart)
 
 void cNBTChunkSerializer::AddMonsterEntity(cMonster * a_Monster)
 {
-	const char * EntityClass = NULL;
+	const char * EntityClass = nullptr;
 	switch (a_Monster->GetMobType())
 	{
 		case mtBat:           EntityClass = "Bat";            break;
diff --git a/src/WorldStorage/ScoreboardSerializer.cpp b/src/WorldStorage/ScoreboardSerializer.cpp
index e30eecf67..404604382 100644
--- a/src/WorldStorage/ScoreboardSerializer.cpp
+++ b/src/WorldStorage/ScoreboardSerializer.cpp
@@ -174,13 +174,13 @@ void cScoreboardSerializer::SaveScoreboardToNBT(cFastNBTWriter & a_Writer)
 	a_Writer.BeginCompound("DisplaySlots");
 
 	cObjective * Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::dsList);
-	a_Writer.AddString("slot_0", (Objective == NULL) ? "" : Objective->GetName());
+	a_Writer.AddString("slot_0", (Objective == nullptr) ? "" : Objective->GetName());
 
 	Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::dsSidebar);
-	a_Writer.AddString("slot_1", (Objective == NULL) ? "" : Objective->GetName());
+	a_Writer.AddString("slot_1", (Objective == nullptr) ? "" : Objective->GetName());
 
 	Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::dsName);
-	a_Writer.AddString("slot_2", (Objective == NULL) ? "" : Objective->GetName());
+	a_Writer.AddString("slot_2", (Objective == nullptr) ? "" : Objective->GetName());
 
 	a_Writer.EndCompound();  // DisplaySlots
 
diff --git a/src/WorldStorage/WSSAnvil.cpp b/src/WorldStorage/WSSAnvil.cpp
index 092b9514c..d0483ab70 100644
--- a/src/WorldStorage/WSSAnvil.cpp
+++ b/src/WorldStorage/WSSAnvil.cpp
@@ -126,7 +126,7 @@ cWSSAnvil::cWSSAnvil(cWorld * a_World, int a_CompressionFactor) :
 		#endif  // _DEBUG
 		
 		gzFile gz = gzopen((FILE_IO_PREFIX + fnam).c_str(), "wb");
-		if (gz != NULL)
+		if (gz != nullptr)
 		{
 			gzwrite(gz, Writer.GetResult().data(), (unsigned)Writer.GetResult().size());
 		}
@@ -193,7 +193,7 @@ bool cWSSAnvil::GetChunkData(const cChunkCoords & a_Chunk, AString & a_Data)
 {
 	cCSLock Lock(m_CS);
 	cMCAFile * File = LoadMCAFile(a_Chunk);
-	if (File == NULL)
+	if (File == nullptr)
 	{
 		return false;
 	}
@@ -208,7 +208,7 @@ bool cWSSAnvil::SetChunkData(const cChunkCoords & a_Chunk, const AString & a_Dat
 {
 	cCSLock Lock(m_CS);
 	cMCAFile * File = LoadMCAFile(a_Chunk);
-	if (File == NULL)
+	if (File == nullptr)
 	{
 		return false;
 	}
@@ -234,7 +234,7 @@ cWSSAnvil::cMCAFile * cWSSAnvil::LoadMCAFile(const cChunkCoords & a_Chunk)
 	// Is it already cached?
 	for (cMCAFiles::iterator itr = m_Files.begin(); itr != m_Files.end(); ++itr)
 	{
-		if (((*itr) != NULL) && ((*itr)->GetRegionX() == RegionX) && ((*itr)->GetRegionZ() == RegionZ))
+		if (((*itr) != nullptr) && ((*itr)->GetRegionX() == RegionX) && ((*itr)->GetRegionZ() == RegionZ))
 		{
 			// Move the file to front and return it:
 			cMCAFile * f = *itr;
@@ -253,9 +253,9 @@ cWSSAnvil::cMCAFile * cWSSAnvil::LoadMCAFile(const cChunkCoords & a_Chunk)
 	cFile::CreateFolder(FILE_IO_PREFIX + FileName);
 	AppendPrintf(FileName, "/r.%d.%d.mca", RegionX, RegionZ);
 	cMCAFile * f = new cMCAFile(FileName, RegionX, RegionZ);
-	if (f == NULL)
+	if (f == nullptr)
 	{
-		return NULL;
+		return nullptr;
 	}
 	m_Files.push_front(f);
 	
@@ -373,7 +373,7 @@ bool cWSSAnvil::LoadChunkFromNBT(const cChunkCoords & a_Chunk, const cParsedNBT
 	// Load the biomes from NBT, if present and valid. First try MCS-style, then Vanilla-style:
 	cChunkDef::BiomeMap BiomeMap;
 	cChunkDef::BiomeMap * Biomes = LoadBiomeMapFromNBT(&BiomeMap, a_NBT, a_NBT.FindChildByName(Level, "MCSBiomes"));
-	if (Biomes == NULL)
+	if (Biomes == nullptr)
 	{
 		// MCS-style biomes not available, load vanilla-style:
 		Biomes = LoadVanillaBiomeMapFromNBT(&BiomeMap, a_NBT, a_NBT.FindChildByName(Level, "Biomes"));
@@ -426,9 +426,9 @@ bool cWSSAnvil::LoadChunkFromNBT(const cChunkCoords & a_Chunk, const cParsedNBT
 	cSetChunkDataPtr SetChunkData(new cSetChunkData(
 		a_Chunk.m_ChunkX, a_Chunk.m_ChunkZ,
 		BlockTypes, MetaData,
-		IsLightValid ? BlockLight : NULL,
-		IsLightValid ? SkyLight : NULL,
-		NULL, Biomes,
+		IsLightValid ? BlockLight : nullptr,
+		IsLightValid ? SkyLight : nullptr,
+		nullptr, Biomes,
 		Entities, BlockEntities,
 		false
 	));
@@ -525,12 +525,12 @@ cChunkDef::BiomeMap * cWSSAnvil::LoadVanillaBiomeMapFromNBT(cChunkDef::BiomeMap
 {
 	if ((a_TagIdx < 0) || (a_NBT.GetType(a_TagIdx) != TAG_ByteArray))
 	{
-		return NULL;
+		return nullptr;
 	}
 	if (a_NBT.GetDataLength(a_TagIdx) != 16 * 16)
 	{
 		// The biomes stored don't match in size
-		return NULL;
+		return nullptr;
 	}
 	const unsigned char * VanillaBiomeData = (const unsigned char *)(a_NBT.GetData(a_TagIdx));
 	for (size_t i = 0; i < ARRAYCOUNT(*a_BiomeMap); i++)
@@ -538,7 +538,7 @@ cChunkDef::BiomeMap * cWSSAnvil::LoadVanillaBiomeMapFromNBT(cChunkDef::BiomeMap
 		if ((VanillaBiomeData)[i] == 0xff)
 		{
 			// Unassigned biomes
-			return NULL;
+			return nullptr;
 		}
 		(*a_BiomeMap)[i] = (EMCSBiome)(VanillaBiomeData[i]);
 	}
@@ -553,12 +553,12 @@ cChunkDef::BiomeMap * cWSSAnvil::LoadBiomeMapFromNBT(cChunkDef::BiomeMap * a_Bio
 {
 	if ((a_TagIdx < 0) || (a_NBT.GetType(a_TagIdx) != TAG_IntArray))
 	{
-		return NULL;
+		return nullptr;
 	}
 	if (a_NBT.GetDataLength(a_TagIdx) != sizeof(*a_BiomeMap))
 	{
 		// The biomes stored don't match in size
-		return NULL;
+		return nullptr;
 	}
 	const char * BiomeData = (a_NBT.GetData(a_TagIdx));
 	for (size_t i = 0; i < ARRAYCOUNT(*a_BiomeMap); i++)
@@ -567,7 +567,7 @@ cChunkDef::BiomeMap * cWSSAnvil::LoadBiomeMapFromNBT(cChunkDef::BiomeMap * a_Bio
 		if ((*a_BiomeMap)[i] == 0xff)
 		{
 			// Unassigned biomes
-			return NULL;
+			return nullptr;
 		}
 	}
 	return a_BiomeMap;
@@ -631,7 +631,7 @@ void cWSSAnvil::LoadBlockEntitiesFromNBT(cBlockEntityList & a_BlockEntities, con
 		BLOCKTYPE BlockType = cChunkDef::GetBlock(a_BlockTypes, RelX, RelY, RelZ);
 		NIBBLETYPE BlockMeta = cChunkDef::GetNibble(a_BlockMetas, RelX, RelY, RelZ);
 		std::auto_ptr<cBlockEntity> be(LoadBlockEntityFromNBT(a_NBT, Child, x, y, z, BlockType, BlockMeta));
-		if (be.get() == NULL)
+		if (be.get() == nullptr)
 		{
 			continue;
 		}
@@ -670,7 +670,7 @@ cBlockEntity * cWSSAnvil::LoadBlockEntityFromNBT(const cParsedNBT & a_NBT, int a
 		case E_BLOCK_WALLSIGN:      return LoadSignFromNBT        (a_NBT, a_Tag, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_WALLSIGN);
 
 		// Blocktypes that have block entities but don't load their contents from disk:
-		case E_BLOCK_ENDER_CHEST:   return NULL;
+		case E_BLOCK_ENDER_CHEST:   return nullptr;
 	}
 
 	// All the other blocktypes should have no entities assigned to them. Report an error:
@@ -686,7 +686,7 @@ cBlockEntity * cWSSAnvil::LoadBlockEntityFromNBT(const cParsedNBT & a_NBT, int a
 		ItemTypeToString(a_BlockType).c_str(), a_BlockType, TypeName.c_str(),
 		a_BlockX, a_BlockY, a_BlockZ
 	);
-	return NULL;
+	return nullptr;
 }
 
 
@@ -836,7 +836,7 @@ cBlockEntity * cWSSAnvil::LoadBeaconFromNBT(const cParsedNBT & a_NBT, int a_TagI
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "Beacon"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	std::auto_ptr<cBeaconEntity> Beacon(new cBeaconEntity(a_BlockX, a_BlockY, a_BlockZ, m_World));
@@ -881,13 +881,13 @@ cBlockEntity * cWSSAnvil::LoadChestFromNBT(const cParsedNBT & a_NBT, int a_TagId
 	//       https://github.com/mc-server/MCServer/blob/d0551e2e0a98a28f31a88d489d17b408e4a7d38d/src/WorldStorage/WSSAnvil.cpp#L637
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "Chest") && !CheckBlockEntityType(a_NBT, a_TagIdx, "TrappedChest"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	int Items = a_NBT.FindChildByName(a_TagIdx, "Items");
 	if ((Items < 0) || (a_NBT.GetType(Items) != TAG_List))
 	{
-		return NULL;  // Make it an empty chest - the chunk loader will provide an empty cChestEntity for this
+		return nullptr;  // Make it an empty chest - the chunk loader will provide an empty cChestEntity for this
 	}
 	std::auto_ptr<cChestEntity> Chest(new cChestEntity(a_BlockX, a_BlockY, a_BlockZ, m_World, a_ChestBlockType));
 	LoadItemGridFromNBT(Chest->GetContents(), a_NBT, Items);
@@ -903,7 +903,7 @@ cBlockEntity * cWSSAnvil::LoadCommandBlockFromNBT(const cParsedNBT & a_NBT, int
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "Control"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	std::auto_ptr<cCommandBlockEntity> CmdBlock(new cCommandBlockEntity(a_BlockX, a_BlockY, a_BlockZ, m_World));
@@ -940,13 +940,13 @@ cBlockEntity * cWSSAnvil::LoadDispenserFromNBT(const cParsedNBT & a_NBT, int a_T
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "Trap"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	int Items = a_NBT.FindChildByName(a_TagIdx, "Items");
 	if ((Items < 0) || (a_NBT.GetType(Items) != TAG_List))
 	{
-		return NULL;  // Make it an empty dispenser - the chunk loader will provide an empty cDispenserEntity for this
+		return nullptr;  // Make it an empty dispenser - the chunk loader will provide an empty cDispenserEntity for this
 	}
 	std::auto_ptr<cDispenserEntity> Dispenser(new cDispenserEntity(a_BlockX, a_BlockY, a_BlockZ, m_World));
 	LoadItemGridFromNBT(Dispenser->GetContents(), a_NBT, Items);
@@ -962,13 +962,13 @@ cBlockEntity * cWSSAnvil::LoadDropperFromNBT(const cParsedNBT & a_NBT, int a_Tag
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "Dropper"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	int Items = a_NBT.FindChildByName(a_TagIdx, "Items");
 	if ((Items < 0) || (a_NBT.GetType(Items) != TAG_List))
 	{
-		return NULL;  // Make it an empty dropper - the chunk loader will provide an empty cDropperEntity for this
+		return nullptr;  // Make it an empty dropper - the chunk loader will provide an empty cDropperEntity for this
 	}
 	std::auto_ptr<cDropperEntity> Dropper(new cDropperEntity(a_BlockX, a_BlockY, a_BlockZ, m_World));
 	LoadItemGridFromNBT(Dropper->GetContents(), a_NBT, Items);
@@ -984,7 +984,7 @@ cBlockEntity * cWSSAnvil::LoadFlowerPotFromNBT(const cParsedNBT & a_NBT, int a_T
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "FlowerPot"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	std::auto_ptr<cFlowerPotEntity> FlowerPot(new cFlowerPotEntity(a_BlockX, a_BlockY, a_BlockZ, m_World));
@@ -1015,13 +1015,13 @@ cBlockEntity * cWSSAnvil::LoadFurnaceFromNBT(const cParsedNBT & a_NBT, int a_Tag
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "Furnace"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	int Items = a_NBT.FindChildByName(a_TagIdx, "Items");
 	if ((Items < 0) || (a_NBT.GetType(Items) != TAG_List))
 	{
-		return NULL;  // Make it an empty furnace - the chunk loader will provide an empty cFurnaceEntity for this
+		return nullptr;  // Make it an empty furnace - the chunk loader will provide an empty cFurnaceEntity for this
 	}
 	
 	std::auto_ptr<cFurnaceEntity> Furnace(new cFurnaceEntity(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, m_World));
@@ -1073,13 +1073,13 @@ cBlockEntity * cWSSAnvil::LoadHopperFromNBT(const cParsedNBT & a_NBT, int a_TagI
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "Hopper"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	int Items = a_NBT.FindChildByName(a_TagIdx, "Items");
 	if ((Items < 0) || (a_NBT.GetType(Items) != TAG_List))
 	{
-		return NULL;  // Make it an empty hopper - the chunk loader will provide an empty cHopperEntity for this
+		return nullptr;  // Make it an empty hopper - the chunk loader will provide an empty cHopperEntity for this
 	}
 	std::auto_ptr<cHopperEntity> Hopper(new cHopperEntity(a_BlockX, a_BlockY, a_BlockZ, m_World));
 	LoadItemGridFromNBT(Hopper->GetContents(), a_NBT, Items);
@@ -1095,7 +1095,7 @@ cBlockEntity * cWSSAnvil::LoadJukeboxFromNBT(const cParsedNBT & a_NBT, int a_Tag
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "RecordPlayer"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	std::auto_ptr<cJukeboxEntity> Jukebox(new cJukeboxEntity(a_BlockX, a_BlockY, a_BlockZ, m_World));
@@ -1116,7 +1116,7 @@ cBlockEntity * cWSSAnvil::LoadMobHeadFromNBT(const cParsedNBT & a_NBT, int a_Tag
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "Skull"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	std::auto_ptr<cMobHeadEntity> MobHead(new cMobHeadEntity(a_BlockX, a_BlockY, a_BlockZ, m_World));
@@ -1151,7 +1151,7 @@ cBlockEntity * cWSSAnvil::LoadNoteBlockFromNBT(const cParsedNBT & a_NBT, int a_T
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "Music"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	std::auto_ptr<cNoteEntity> NoteBlock(new cNoteEntity(a_BlockX, a_BlockY, a_BlockZ, m_World));
@@ -1172,7 +1172,7 @@ cBlockEntity * cWSSAnvil::LoadSignFromNBT(const cParsedNBT & a_NBT, int a_TagIdx
 	// Check if the data has a proper type:
 	if (!CheckBlockEntityType(a_NBT, a_TagIdx, "Sign"))
 	{
-		return NULL;
+		return nullptr;
 	}
 
 	std::auto_ptr<cSignEntity> Sign(new cSignEntity(a_BlockType, a_BlockX, a_BlockY, a_BlockZ, m_World));
@@ -1744,7 +1744,7 @@ void cWSSAnvil::LoadItemFrameFromNBT(cEntityList & a_Entities, const cParsedNBT
 
 void cWSSAnvil::LoadArrowFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
-	std::auto_ptr<cArrowEntity> Arrow(new cArrowEntity(NULL, 0, 0, 0, Vector3d(0, 0, 0)));
+	std::auto_ptr<cArrowEntity> Arrow(new cArrowEntity(nullptr, 0, 0, 0, Vector3d(0, 0, 0)));
 	if (!LoadProjectileBaseFromNBT(*Arrow.get(), a_NBT, a_TagIdx))
 	{
 		return;
@@ -1808,7 +1808,7 @@ void cWSSAnvil::LoadArrowFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 
 void cWSSAnvil::LoadSplashPotionFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
-	std::auto_ptr<cSplashPotionEntity> SplashPotion(new cSplashPotionEntity(NULL, 0, 0, 0, Vector3d(0, 0, 0), cItem()));
+	std::auto_ptr<cSplashPotionEntity> SplashPotion(new cSplashPotionEntity(nullptr, 0, 0, 0, Vector3d(0, 0, 0), cItem()));
 	if (!LoadProjectileBaseFromNBT(*SplashPotion.get(), a_NBT, a_TagIdx))
 	{
 		return;
@@ -1832,7 +1832,7 @@ void cWSSAnvil::LoadSplashPotionFromNBT(cEntityList & a_Entities, const cParsedN
 
 void cWSSAnvil::LoadSnowballFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
-	std::auto_ptr<cThrownSnowballEntity> Snowball(new cThrownSnowballEntity(NULL, 0, 0, 0, Vector3d(0, 0, 0)));
+	std::auto_ptr<cThrownSnowballEntity> Snowball(new cThrownSnowballEntity(nullptr, 0, 0, 0, Vector3d(0, 0, 0)));
 	if (!LoadProjectileBaseFromNBT(*Snowball.get(), a_NBT, a_TagIdx))
 	{
 		return;
@@ -1848,7 +1848,7 @@ void cWSSAnvil::LoadSnowballFromNBT(cEntityList & a_Entities, const cParsedNBT &
 
 void cWSSAnvil::LoadEggFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
-	std::auto_ptr<cThrownEggEntity> Egg(new cThrownEggEntity(NULL, 0, 0, 0, Vector3d(0, 0, 0)));
+	std::auto_ptr<cThrownEggEntity> Egg(new cThrownEggEntity(nullptr, 0, 0, 0, Vector3d(0, 0, 0)));
 	if (!LoadProjectileBaseFromNBT(*Egg.get(), a_NBT, a_TagIdx))
 	{
 		return;
@@ -1864,7 +1864,7 @@ void cWSSAnvil::LoadEggFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NB
 
 void cWSSAnvil::LoadFireballFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
-	std::auto_ptr<cGhastFireballEntity> Fireball(new cGhastFireballEntity(NULL, 0, 0, 0, Vector3d(0, 0, 0)));
+	std::auto_ptr<cGhastFireballEntity> Fireball(new cGhastFireballEntity(nullptr, 0, 0, 0, Vector3d(0, 0, 0)));
 	if (!LoadProjectileBaseFromNBT(*Fireball.get(), a_NBT, a_TagIdx))
 	{
 		return;
@@ -1880,7 +1880,7 @@ void cWSSAnvil::LoadFireballFromNBT(cEntityList & a_Entities, const cParsedNBT &
 
 void cWSSAnvil::LoadFireChargeFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
-	std::auto_ptr<cFireChargeEntity> FireCharge(new cFireChargeEntity(NULL, 0, 0, 0, Vector3d(0, 0, 0)));
+	std::auto_ptr<cFireChargeEntity> FireCharge(new cFireChargeEntity(nullptr, 0, 0, 0, Vector3d(0, 0, 0)));
 	if (!LoadProjectileBaseFromNBT(*FireCharge.get(), a_NBT, a_TagIdx))
 	{
 		return;
@@ -1896,7 +1896,7 @@ void cWSSAnvil::LoadFireChargeFromNBT(cEntityList & a_Entities, const cParsedNBT
 
 void cWSSAnvil::LoadThrownEnderpearlFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
-	std::auto_ptr<cThrownEnderPearlEntity> Enderpearl(new cThrownEnderPearlEntity(NULL, 0, 0, 0, Vector3d(0, 0, 0)));
+	std::auto_ptr<cThrownEnderPearlEntity> Enderpearl(new cThrownEnderPearlEntity(nullptr, 0, 0, 0, Vector3d(0, 0, 0)));
 	if (!LoadProjectileBaseFromNBT(*Enderpearl.get(), a_NBT, a_TagIdx))
 	{
 		return;
@@ -2853,7 +2853,7 @@ bool cWSSAnvil::cMCAFile::OpenFile(bool a_IsForReading)
 	if (m_File.Read(m_Header, sizeof(m_Header)) != sizeof(m_Header))
 	{
 		// Cannot read the header - perhaps the file has just been created?
-		// Try writing a NULL header (both chunk offsets and timestamps):
+		// Try writing a nullptr header (both chunk offsets and timestamps):
 		memset(m_Header, 0, sizeof(m_Header));
 		if (
 			(m_File.Write(m_Header, sizeof(m_Header)) != sizeof(m_Header)) ||  // Real header - chunk offsets
diff --git a/src/WorldStorage/WSSAnvil.h b/src/WorldStorage/WSSAnvil.h
index 591ec6757..9c579a617 100644
--- a/src/WorldStorage/WSSAnvil.h
+++ b/src/WorldStorage/WSSAnvil.h
@@ -113,10 +113,10 @@ protected:
 	/// Saves the chunk into NBT data using a_Writer; returns true on success
 	bool SaveChunkToNBT(const cChunkCoords & a_Chunk, cFastNBTWriter & a_Writer);
 	
-	/// Loads the chunk's biome map from vanilla-format; returns a_BiomeMap if biomes present and valid, NULL otherwise
+	/// Loads the chunk's biome map from vanilla-format; returns a_BiomeMap if biomes present and valid, nullptr otherwise
 	cChunkDef::BiomeMap * LoadVanillaBiomeMapFromNBT(cChunkDef::BiomeMap * a_BiomeMap, const cParsedNBT & a_NBT, int a_TagIdx);
 	
-	/// Loads the chunk's biome map from MCS format; returns a_BiomeMap if biomes present and valid, NULL otherwise
+	/// Loads the chunk's biome map from MCS format; returns a_BiomeMap if biomes present and valid, nullptr otherwise
 	cChunkDef::BiomeMap * LoadBiomeMapFromNBT(cChunkDef::BiomeMap * a_BiomeMap, const cParsedNBT & a_NBT, int a_TagIdx);
 	
 	/// Loads the chunk's entities from NBT data (a_Tag is the Level\\Entities list tag; may be -1)
@@ -126,7 +126,7 @@ protected:
 	void LoadBlockEntitiesFromNBT(cBlockEntityList & a_BlockEntitites, const cParsedNBT & a_NBT, int a_Tag, BLOCKTYPE * a_BlockTypes, NIBBLETYPE * a_BlockMetas);
 	
 	/** Loads the data for a block entity from the specified NBT tag.
-	Returns the loaded block entity, or NULL upon failure. */
+	Returns the loaded block entity, or nullptr upon failure. */
 	cBlockEntity * LoadBlockEntityFromNBT(const cParsedNBT & a_NBT, int a_Tag, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
 	/// Loads a cItem contents from the specified NBT tag; returns true if successful. Doesn't load the Slot tag
diff --git a/src/WorldStorage/WorldStorage.cpp b/src/WorldStorage/WorldStorage.cpp
index c611bfd90..31318ee67 100644
--- a/src/WorldStorage/WorldStorage.cpp
+++ b/src/WorldStorage/WorldStorage.cpp
@@ -39,8 +39,8 @@ protected:
 
 cWorldStorage::cWorldStorage(void) :
 	super("cWorldStorage"),
-	m_World(NULL),
-	m_SaveSchema(NULL)
+	m_World(nullptr),
+	m_SaveSchema(nullptr)
 {
 }
 
diff --git a/src/XMLParser.h b/src/XMLParser.h
index e39405529..5b53e55cf 100644
--- a/src/XMLParser.h
+++ b/src/XMLParser.h
@@ -68,7 +68,7 @@ protected:
 3, Create an instance of your class:
 	CMyParser Parser;
 4, Call Create():
-	Parser.Create(NULL, NULL);
+	Parser.Create(nullptr, nullptr);
 4, Call Parse(), repeatedly:
 	Parser.Parse(Buffer, Length);
 */
@@ -84,7 +84,7 @@ public:
 
 	CExpatImpl ()
 	{
-		m_p = NULL;
+		m_p = nullptr;
 	}
 
 	// @cmember Destructor
@@ -99,24 +99,24 @@ public:
 
 	// @cmember Create a parser
 
-	bool Create (const XML_Char * pszEncoding = NULL, const XML_Char * pszSep = NULL)
+	bool Create (const XML_Char * pszEncoding = nullptr, const XML_Char * pszSep = nullptr)
 	{
 		// Destroy the old parser
 		Destroy ();
 
-		// If the encoding or seperator are empty, then NULL
-		if (pszEncoding != NULL && pszEncoding [0] == 0)
+		// If the encoding or seperator are empty, then nullptr
+		if (pszEncoding != nullptr && pszEncoding [0] == 0)
 		{
-			pszEncoding = NULL;
+			pszEncoding = nullptr;
 		}
-		if (pszSep != NULL && pszSep [0] == 0)
+		if (pszSep != nullptr && pszSep [0] == 0)
 		{
-			pszSep = NULL;
+			pszSep = nullptr;
 		}
 
 		// Create the new parser
-		m_p = XML_ParserCreate_MM (pszEncoding, NULL, pszSep);
-		if (m_p == NULL)
+		m_p = XML_ParserCreate_MM (pszEncoding, nullptr, pszSep);
+		if (m_p == nullptr)
 		{
 			return false;
 		}
@@ -134,11 +134,11 @@ public:
 
 	void Destroy (void)
 	{
-		if (m_p != NULL)
+		if (m_p != nullptr)
 		{
 			XML_ParserFree (m_p);
 		}
-		m_p = NULL;
+		m_p = nullptr;
 	}
 
 
@@ -146,7 +146,7 @@ public:
 
 	bool Parse (const char *pszBuffer, int nLength, bool fIsFinal = true)
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		return XML_Parse (m_p, pszBuffer, nLength, fIsFinal) != 0;
 	}
 
@@ -154,7 +154,7 @@ public:
 
 	bool ParseBuffer (int nLength, bool fIsFinal = true)
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		return XML_ParseBuffer (m_p, nLength, fIsFinal) != 0;
 	}
 
@@ -162,7 +162,7 @@ public:
 
 	void *GetBuffer (int nLength)
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		return XML_GetBuffer (m_p, nLength);
 	}
 
@@ -174,23 +174,23 @@ protected:
 
 	void EnableStartElementHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetStartElementHandler (m_p, fEnable ? StartElementHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetStartElementHandler (m_p, fEnable ? StartElementHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable the end element handler
 
 	void EnableEndElementHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetEndElementHandler (m_p, fEnable ? EndElementHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetEndElementHandler (m_p, fEnable ? EndElementHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable the element handlers
 
 	void EnableElementHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		EnableStartElementHandler (fEnable);
 		EnableEndElementHandler (fEnable);
 	}
@@ -199,47 +199,47 @@ protected:
 
 	void EnableCharacterDataHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetCharacterDataHandler (m_p, fEnable ? CharacterDataHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetCharacterDataHandler (m_p, fEnable ? CharacterDataHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable the processing instruction handler
 
 	void EnableProcessingInstructionHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetProcessingInstructionHandler (m_p, fEnable ? ProcessingInstructionHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetProcessingInstructionHandler (m_p, fEnable ? ProcessingInstructionHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable the comment handler
 
 	void EnableCommentHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetCommentHandler (m_p, fEnable ? CommentHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetCommentHandler (m_p, fEnable ? CommentHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable the start CDATA section handler
 
 	void EnableStartCdataSectionHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetStartCdataSectionHandler (m_p, fEnable ? StartCdataSectionHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetStartCdataSectionHandler (m_p, fEnable ? StartCdataSectionHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable the end CDATA section handler
 
 	void EnableEndCdataSectionHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetEndCdataSectionHandler (m_p, fEnable ? EndCdataSectionHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetEndCdataSectionHandler (m_p, fEnable ? EndCdataSectionHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable the CDATA section handlers
 
 	void EnableCdataSectionHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		EnableStartCdataSectionHandler (fEnable);
 		EnableEndCdataSectionHandler (fEnable);
 	}
@@ -248,45 +248,45 @@ protected:
 	
 	void EnableDefaultHandler (bool fEnable = true, bool fExpand = true)
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		if (fExpand)
 		{
-			XML_SetDefaultHandlerExpand (m_p, fEnable ? DefaultHandler : NULL);
+			XML_SetDefaultHandlerExpand (m_p, fEnable ? DefaultHandler : nullptr);
 		}
 		else
-			XML_SetDefaultHandler (m_p, fEnable ? DefaultHandler : NULL);
+			XML_SetDefaultHandler (m_p, fEnable ? DefaultHandler : nullptr);
 	}
 	
 	// @cmember Enable/Disable external entity ref handler
 	
 	void EnableExternalEntityRefHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetExternalEntityRefHandler (m_p, fEnable ? ExternalEntityRefHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetExternalEntityRefHandler (m_p, fEnable ? ExternalEntityRefHandler : nullptr);
 	}
 	
 	// @cmember Enable/Disable unknown encoding handler
 	
 	void EnableUnknownEncodingHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetUnknownEncodingHandler (m_p, fEnable ? UnknownEncodingHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetUnknownEncodingHandler (m_p, fEnable ? UnknownEncodingHandler : nullptr);
 	}
 	
 	// @cmember Enable/Disable start namespace handler
 	
 	void EnableStartNamespaceDeclHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetStartNamespaceDeclHandler (m_p, fEnable ? StartNamespaceDeclHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetStartNamespaceDeclHandler (m_p, fEnable ? StartNamespaceDeclHandler : nullptr);
 	}
 	
 	// @cmember Enable/Disable end namespace handler
 	
 	void EnableEndNamespaceDeclHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetEndNamespaceDeclHandler (m_p, fEnable ? EndNamespaceDeclHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetEndNamespaceDeclHandler (m_p, fEnable ? EndNamespaceDeclHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable namespace handlers
@@ -301,32 +301,32 @@ protected:
 
 	void EnableXmlDeclHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetXmlDeclHandler (m_p, fEnable ? XmlDeclHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetXmlDeclHandler (m_p, fEnable ? XmlDeclHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable the start DOCTYPE declaration handler
 
 	void EnableStartDoctypeDeclHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
-		XML_SetStartDoctypeDeclHandler (m_p, fEnable ? StartDoctypeDeclHandler : NULL);
+		assert (m_p != nullptr);
+		XML_SetStartDoctypeDeclHandler (m_p, fEnable ? StartDoctypeDeclHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable the end DOCTYPE declaration handler
 
 	void EnableEndDoctypeDeclHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		XML_SetEndDoctypeDeclHandler (m_p,
-			fEnable ? EndDoctypeDeclHandler : NULL);
+			fEnable ? EndDoctypeDeclHandler : nullptr);
 	}
 
 	// @cmember Enable/Disable the DOCTYPE declaration handler
 
 	void EnableDoctypeDeclHandler (bool fEnable = true)
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		EnableStartDoctypeDeclHandler (fEnable);
 		EnableEndDoctypeDeclHandler (fEnable);
 	}
@@ -338,7 +338,7 @@ public:
 
 	enum XML_Error GetErrorCode ()
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		return XML_GetErrorCode (m_p);
 	}
 
@@ -346,7 +346,7 @@ public:
 
 	long GetCurrentByteIndex ()
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		return XML_GetCurrentByteIndex (m_p);
 	}
 
@@ -354,7 +354,7 @@ public:
 
 	int GetCurrentLineNumber ()
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		return XML_GetCurrentLineNumber (m_p);
 	}
 
@@ -362,7 +362,7 @@ public:
 
 	int GetCurrentColumnNumber ()
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		return XML_GetCurrentColumnNumber (m_p);
 	}
 
@@ -370,7 +370,7 @@ public:
 
 	int GetCurrentByteCount ()
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		return XML_GetCurrentByteCount (m_p);
 	}
 
@@ -378,7 +378,7 @@ public:
 
 	const char *GetInputContext (int *pnOffset, int *pnSize)
 	{
-		assert (m_p != NULL);
+		assert (m_p != nullptr);
 		return XML_GetInputContext (m_p, pnOffset, pnSize);
 	}
 
@@ -682,17 +682,17 @@ protected:
 
 	XML_Parser m_p;
 	
-	/// Returns the value of the specified attribute, if found; NULL otherwise
+	/// Returns the value of the specified attribute, if found; nullptr otherwise
 	static const XML_Char * FindAttr(const XML_Char ** iAttrs, const XML_Char * iAttrToFind)
 	{
-		for (const XML_Char ** Attr = iAttrs; *Attr != NULL; Attr += 2)
+		for (const XML_Char ** Attr = iAttrs; *Attr != nullptr; Attr += 2)
 		{
 			if (strcmp(*Attr, iAttrToFind) == 0)
 			{
 				return *(Attr + 1);
 			}
 		}  // for Attr - iAttrs[]
-		return NULL;
+		return nullptr;
 	}
 } ;
 
diff --git a/src/main.cpp b/src/main.cpp
index b1cfd6976..5391fa9c9 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -133,8 +133,8 @@ LONG WINAPI LastChanceExceptionFilter(__in struct _EXCEPTION_POINTERS * a_Except
 	ExcInformation.ClientPointers = 0;
 
 	// Write the dump file:
-	HANDLE dumpFile = CreateFile(g_DumpFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-	g_WriteMiniDump(GetCurrentProcess(), GetCurrentProcessId(), dumpFile, g_DumpFlags, (a_ExceptionInfo) ? &ExcInformation : NULL, NULL, NULL);
+	HANDLE dumpFile = CreateFile(g_DumpFileName, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
+	g_WriteMiniDump(GetCurrentProcess(), GetCurrentProcessId(), dumpFile, g_DumpFlags, (a_ExceptionInfo) ? &ExcInformation : nullptr, nullptr, nullptr);
 	CloseHandle(dumpFile);
 
 	// Revert to old stack:
@@ -190,7 +190,7 @@ int main( int argc, char **argv)
 	#if defined(_WIN32) && !defined(_WIN64) && defined(_MSC_VER)
 	HINSTANCE hDbgHelp = LoadLibrary("DBGHELP.DLL");
 	g_WriteMiniDump = (pMiniDumpWriteDump)GetProcAddress(hDbgHelp, "MiniDumpWriteDump");
-	if (g_WriteMiniDump != NULL)
+	if (g_WriteMiniDump != nullptr)
 	{
 		_snprintf_s(g_DumpFileName, ARRAYCOUNT(g_DumpFileName), _TRUNCATE, "crash_mcs_%x.dmp", GetCurrentProcessId());
 		SetUnhandledExceptionFilter(LastChanceExceptionFilter);
@@ -272,7 +272,7 @@ int main( int argc, char **argv)
 		}
 		else if (NoCaseCompare(Arg, "nooutbuf") == 0)
 		{
-			setvbuf(stdout, NULL, _IONBF, 0);
+			setvbuf(stdout, nullptr, _IONBF, 0);
 		}
 	}  // for i - argv[]