diff --git a/Minecraft.Client/Level/ServerLevel.cpp b/Minecraft.Client/Level/ServerLevel.cpp
index 7952bd87f..3326dcf98 100644
--- a/Minecraft.Client/Level/ServerLevel.cpp
+++ b/Minecraft.Client/Level/ServerLevel.cpp
@@ -671,11 +671,11 @@ void ServerLevel::tick(std::shared_ptr<Entity> e, bool actual)
 	{
         e->remove();
     }
-	if (!server->isNpcsEnabled() && (dynamic_pointer_cast<Npc>(e) != NULL))
+	if (!server->isNpcsEnabled() && (std::dynamic_pointer_cast<Npc>(e) != NULL))
 	{
 		e->remove();
 	}
-    if (e->rider.lock() == NULL || (dynamic_pointer_cast<Player>(e->rider.lock())==NULL) )		// 4J - was !(e->rider instanceof Player)
+    if (e->rider.lock() == NULL || (std::dynamic_pointer_cast<Player>(e->rider.lock())==NULL) )		// 4J - was !(e->rider instanceof Player)
 	{
         Level::tick(e, actual);
     }
@@ -814,7 +814,7 @@ void ServerLevel::generateBonusItemsNearSpawn()
 			
 			if( getTile( x, y, z ) == Tile::chest_Id )
 			{
-				std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(getTileEntity(x, y, z));
+				std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(getTileEntity(x, y, z));
 				if (chest != NULL)
 				{
 					if( chest->isBonusChest )
@@ -1019,7 +1019,7 @@ std::shared_ptr<Explosion> ServerLevel::explode(std::shared_ptr<Entity> source,
 	std::vector<std::shared_ptr<ServerPlayer> > sentTo;
 	for(AUTO_VAR(it, players.begin()); it != players.end(); ++it)
 	{
-		std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(*it);
+		std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(*it);
 		if (player->dimension != dimension->id) continue;
 
 		bool knockbackOnly = false;
@@ -1188,7 +1188,7 @@ void ServerLevel::runQueuedSendTileUpdates()
 bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
 {
 	// If its an item entity, and we've got to our capacity, delete the oldest
-	if( dynamic_pointer_cast<ItemEntity>(e) != NULL )
+	if( std::dynamic_pointer_cast<ItemEntity>(e) != NULL )
 	{
 //		printf("Adding item entity count %d\n",m_itemEntities.size());
 		EnterCriticalSection(&m_limiterCS);
@@ -1200,7 +1200,7 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
 		LeaveCriticalSection(&m_limiterCS);
 	}
 	// If its an hanging entity, and we've got to our capacity, delete the oldest
-	else if( dynamic_pointer_cast<HangingEntity>(e) != NULL )
+	else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL )
 	{
 		//		printf("Adding item entity count %d\n",m_itemEntities.size());
 		EnterCriticalSection(&m_limiterCS);
@@ -1217,7 +1217,7 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
 		LeaveCriticalSection(&m_limiterCS);
 	}
 	// If its an arrow entity, and we've got to our capacity, delete the oldest
-	else if( dynamic_pointer_cast<Arrow>(e) != NULL )
+	else if( std::dynamic_pointer_cast<Arrow>(e) != NULL )
 	{
 //		printf("Adding arrow entity count %d\n",m_arrowEntities.size());
 		EnterCriticalSection(&m_limiterCS);
@@ -1229,7 +1229,7 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
 		LeaveCriticalSection(&m_limiterCS);
 	}
 	// If its an experience orb entity, and we've got to our capacity, delete the oldest
-	else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
+	else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
 	{
 //		printf("Adding arrow entity count %d\n",m_arrowEntities.size());
 		EnterCriticalSection(&m_limiterCS);
@@ -1246,41 +1246,41 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
 // Maintain a cound of primed tnt & falling tiles in this level
 void ServerLevel::entityAddedExtra(std::shared_ptr<Entity> e)
 {
-	if( dynamic_pointer_cast<ItemEntity>(e) != NULL )
+	if( std::dynamic_pointer_cast<ItemEntity>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 		m_itemEntities.push_back(e);
 //		printf("entity added: item entity count now %d\n",m_itemEntities.size());
 		LeaveCriticalSection(&m_limiterCS);
 	}
-	else if( dynamic_pointer_cast<HangingEntity>(e) != NULL )
+	else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 		m_hangingEntities.push_back(e);
 		//		printf("entity added: item entity count now %d\n",m_itemEntities.size());
 		LeaveCriticalSection(&m_limiterCS);
 	}
-	else if( dynamic_pointer_cast<Arrow>(e) != NULL )
+	else if( std::dynamic_pointer_cast<Arrow>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 		m_arrowEntities.push_back(e);
 //		printf("entity added: arrow entity count now %d\n",m_arrowEntities.size());
 		LeaveCriticalSection(&m_limiterCS);
 	}
-	else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
+	else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 		m_experienceOrbEntities.push_back(e);
 //		printf("entity added: experience orb entity count now %d\n",m_arrowEntities.size());
 		LeaveCriticalSection(&m_limiterCS);
 	}
-	else if( dynamic_pointer_cast<PrimedTnt>(e) != NULL )
+	else if( std::dynamic_pointer_cast<PrimedTnt>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 		m_primedTntCount++;
 		LeaveCriticalSection(&m_limiterCS);
 	}
-	else if( dynamic_pointer_cast<FallingTile>(e) != NULL )
+	else if( std::dynamic_pointer_cast<FallingTile>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 		m_fallingTileCount++;
@@ -1291,7 +1291,7 @@ void ServerLevel::entityAddedExtra(std::shared_ptr<Entity> e)
 // Maintain a cound of primed tnt & falling tiles in this level, and remove any item entities from our list
 void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e)
 {
-	if( dynamic_pointer_cast<ItemEntity>(e) != NULL )
+	if( std::dynamic_pointer_cast<ItemEntity>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 //		printf("entity removed: item entity count %d\n",m_itemEntities.size());
@@ -1304,7 +1304,7 @@ void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e)
 //		printf("entity removed: item entity count now %d\n",m_itemEntities.size());
 		LeaveCriticalSection(&m_limiterCS);
 	} 
-	else if( dynamic_pointer_cast<HangingEntity>(e) != NULL )
+	else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 		//		printf("entity removed: item entity count %d\n",m_itemEntities.size());
@@ -1317,7 +1317,7 @@ void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e)
 		//		printf("entity removed: item entity count now %d\n",m_itemEntities.size());
 		LeaveCriticalSection(&m_limiterCS);
 	} 
-	else if( dynamic_pointer_cast<Arrow>(e) != NULL )
+	else if( std::dynamic_pointer_cast<Arrow>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 //		printf("entity removed: arrow entity count %d\n",m_arrowEntities.size());
@@ -1330,7 +1330,7 @@ void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e)
 //		printf("entity removed: arrow entity count now %d\n",m_arrowEntities.size());
 		LeaveCriticalSection(&m_limiterCS);
 	} 
-	else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
+	else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 //		printf("entity removed: experience orb entity count %d\n",m_arrowEntities.size());
@@ -1343,13 +1343,13 @@ void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e)
 //		printf("entity removed: experience orb entity count now %d\n",m_arrowEntities.size());
 		LeaveCriticalSection(&m_limiterCS);
 	} 
-	else if( dynamic_pointer_cast<PrimedTnt>(e) != NULL )
+	else if( std::dynamic_pointer_cast<PrimedTnt>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 		m_primedTntCount--;
 		LeaveCriticalSection(&m_limiterCS);
 	}
-	else if( dynamic_pointer_cast<FallingTile>(e) != NULL )
+	else if( std::dynamic_pointer_cast<FallingTile>(e) != NULL )
 	{
 		EnterCriticalSection(&m_limiterCS);
 		m_fallingTileCount--;
diff --git a/Minecraft.Client/Level/ServerLevelListener.cpp b/Minecraft.Client/Level/ServerLevelListener.cpp
index f0cd1ab6e..ac92c1657 100644
--- a/Minecraft.Client/Level/ServerLevelListener.cpp
+++ b/Minecraft.Client/Level/ServerLevelListener.cpp
@@ -48,7 +48,7 @@ void ServerLevelListener::entityRemoved(std::shared_ptr<Entity> entity)
 // 4J added
 void ServerLevelListener::playerRemoved(std::shared_ptr<Entity> entity)
 {
-	std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(entity);
+	std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(entity);
 	player->getLevel()->getTracker()->removePlayer(entity);
 }
 
@@ -76,7 +76,7 @@ void ServerLevelListener::playSound(std::shared_ptr<Entity> entity,int iSound, d
 	{	
 		// 4J-PB - I don't want to broadcast player sounds to my local machine, since we're already playing these in the LevelRenderer::playSound.
 		// The PC version does seem to do this and the result is I can stop walking , and then I'll hear my footstep sound with a delay
-		std::shared_ptr<Player> player= dynamic_pointer_cast<Player>(entity);
+		std::shared_ptr<Player> player= std::dynamic_pointer_cast<Player>(entity);
 		server->getPlayers()->broadcast(player,x, y, z, volume > 1 ? 16 * volume : 16, level->dimension->id, std::shared_ptr<LevelSoundPacket>(new LevelSoundPacket(iSound, x, y, z, volume, pitch)));
 	}
 }
diff --git a/Minecraft.Client/Minecraft.cpp b/Minecraft.Client/Minecraft.cpp
index 80590a9fd..c1c2b4b89 100644
--- a/Minecraft.Client/Minecraft.cpp
+++ b/Minecraft.Client/Minecraft.cpp
@@ -2723,7 +2723,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 							{
 							default:
 								{
-									std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
+									std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
 
 									if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
 									{
@@ -2752,7 +2752,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 								break;
 							default:
 								{
-									std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
+									std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
 
 									if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
 									{
@@ -2783,13 +2783,13 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 							case Item::shears_Id:
 								{								
 									if(player->isAllowedToAttackAnimals()) *piAction=IDS_TOOLTIPS_HIT;
-									std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
+									std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
 									if(!animal->isBaby()) *piUse=IDS_TOOLTIPS_SHEAR;
 								}
 								break;
 							default:
 								{
-									std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
+									std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
 
 									if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
 									{
@@ -2811,7 +2811,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 						*piAction=IDS_TOOLTIPS_MINE;
 
 						// are we in the boat already?
-						if (dynamic_pointer_cast<Boat>( player->riding ) != NULL)
+						if (std::dynamic_pointer_cast<Boat>( player->riding ) != NULL)
 						{
 							*piUse=IDS_TOOLTIPS_EXIT;
 						}
@@ -2823,13 +2823,13 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 					case eTYPE_MINECART:
 						*piAction=IDS_TOOLTIPS_MINE;
 						// are we in the minecart already?
-						if (dynamic_pointer_cast<Minecart>( player->riding ) != NULL)
+						if (std::dynamic_pointer_cast<Minecart>( player->riding ) != NULL)
 						{
 							*piUse=IDS_TOOLTIPS_EXIT;
 						}
 						else
 						{
-							switch(dynamic_pointer_cast<Minecart>(hitResult->entity)->type)
+							switch(std::dynamic_pointer_cast<Minecart>(hitResult->entity)->type)
 							{
 							case Minecart::RIDEABLE:
 								*piUse=IDS_TOOLTIPS_RIDE;
@@ -2871,7 +2871,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 							{
 							case Item::dye_powder_Id:
 								{
-									std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(hitResult->entity);
+									std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(hitResult->entity);
 									// convert to tile-based color value (0 is white instead of black)
 									int newColor = ClothTile::getTileDataForItemAuxValue(heldItem->getAuxValue());
 
@@ -2884,7 +2884,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 								break;
 							case Item::shears_Id:
 								{
-									std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(hitResult->entity);
+									std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(hitResult->entity);
 
 									// can only shear a sheep that hasn't been sheared
 									if(!sheep->isSheared() )
@@ -2896,7 +2896,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 								break;
 							default:
 								{
-									std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
+									std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
 
 									if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
 									{
@@ -2911,18 +2911,18 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 					case eTYPE_PIG:
 						// can ride a pig
 						if(player->isAllowedToAttackAnimals()) *piAction=IDS_TOOLTIPS_HIT;
-						if (dynamic_pointer_cast<Pig>( player->riding ) != NULL)
+						if (std::dynamic_pointer_cast<Pig>( player->riding ) != NULL)
 						{
 							*piUse=IDS_TOOLTIPS_EXIT;
 						}
 						else
 						{
 							// does the pig have a saddle?
-							if(dynamic_pointer_cast<Pig>(hitResult->entity)->hasSaddle())
+							if(std::dynamic_pointer_cast<Pig>(hitResult->entity)->hasSaddle())
 							{
 								*piUse=IDS_TOOLTIPS_RIDE;
 							}
-							else if (!dynamic_pointer_cast<Pig>(hitResult->entity)->isBaby())
+							else if (!std::dynamic_pointer_cast<Pig>(hitResult->entity)->isBaby())
 							{
 								if(player->inventory->IsHeldItem())
 								{
@@ -2936,7 +2936,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 										break;
 									default:
 										{
-											std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
+											std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
 
 											if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
 											{
@@ -2955,7 +2955,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 						{
 							int iID=-1;
 							std::shared_ptr<ItemInstance> heldItem=nullptr;
-							std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(hitResult->entity);
+							std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(hitResult->entity);
 
 							if(player->inventory->IsHeldItem())
 							{
@@ -3045,7 +3045,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 						{
 							int iID=-1;
 							std::shared_ptr<ItemInstance> heldItem=nullptr;
-							std::shared_ptr<Ozelot> ocelot = dynamic_pointer_cast<Ozelot>(hitResult->entity);
+							std::shared_ptr<Ozelot> ocelot = std::dynamic_pointer_cast<Ozelot>(hitResult->entity);
 
 							if(player->inventory->IsHeldItem())
 							{
@@ -3106,7 +3106,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 					case eTYPE_PLAYER:
 						{
 							// Fix for #58576 - TU6: Content: Gameplay: Hit button prompt is available when attacking a host who has "Invisible" option turned on
-							std::shared_ptr<Player> TargetPlayer = dynamic_pointer_cast<Player>(hitResult->entity);
+							std::shared_ptr<Player> TargetPlayer = std::dynamic_pointer_cast<Player>(hitResult->entity);
 
 							if(!TargetPlayer->hasInvisiblePrivilege()) // This means they are invisible, not just that they have the privilege
 							{
@@ -3119,7 +3119,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 						break;
 					case eTYPE_ITEM_FRAME:
 						{
-							std::shared_ptr<ItemFrame> itemFrame = dynamic_pointer_cast<ItemFrame>(hitResult->entity);
+							std::shared_ptr<ItemFrame> itemFrame = std::dynamic_pointer_cast<ItemFrame>(hitResult->entity);
 
 							// is the frame occupied?
 							if(itemFrame->getItem()!=NULL)
@@ -3141,7 +3141,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 						break;
 					case eTYPE_VILLAGER:
 						{
-							std::shared_ptr<Villager> villager = dynamic_pointer_cast<Villager>(hitResult->entity);
+							std::shared_ptr<Villager> villager = std::dynamic_pointer_cast<Villager>(hitResult->entity);
 							if (!villager->isBaby())
 							{
 								*piUse=IDS_TOOLTIPS_TRADE;
@@ -3151,7 +3151,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 						break; 
 					case eTYPE_ZOMBIE:
 						{
-							std::shared_ptr<Zombie> zomb = dynamic_pointer_cast<Zombie>(hitResult->entity);
+							std::shared_ptr<Zombie> zomb = std::dynamic_pointer_cast<Zombie>(hitResult->entity);
 							std::shared_ptr<ItemInstance> heldItem=nullptr;
 
 							if(player->inventory->IsHeldItem())
@@ -3337,9 +3337,9 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 
 				if((player->ullButtonsPressed&(1LL<<MINECRAFT_ACTION_SPAWN_CREEPER)) && app.GetMobsDontAttackEnabled())
 				{
-					//std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(Creeper::_class->newInstance( level ));
-					//std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
-					std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(std::shared_ptr<Spider>(new Spider( level )));
+					//std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(Creeper::_class->newInstance( level ));
+					//std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
+					std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(std::shared_ptr<Spider>(new Spider( level )));
 					mob->moveTo(player->x+1, player->y, player->z+1, level->random->nextFloat() * 360, 0);
 					level->addEntity(mob);
 				}
@@ -3369,14 +3369,14 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
 
 		if((player->ullButtonsPressed&(1LL<<MINECRAFT_ACTION_INVENTORY)) && gameMode->isInputAllowed(MINECRAFT_ACTION_INVENTORY))
 		{
-			std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player );
+			std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player );
 			ui.PlayUISFX(eSFX_Press);
 			app.LoadInventoryMenu(iPad,player);
 		}
 
 		if((player->ullButtonsPressed&(1LL<<MINECRAFT_ACTION_CRAFTING)) && gameMode->isInputAllowed(MINECRAFT_ACTION_CRAFTING))
 		{
-			std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player );
+			std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player );
 
 			// 4J-PB - reordered the if statement so creative mode doesn't bring up the crafting table
 			// Fix for #39014 - TU5:  Creative Mode:  Pressing X to access the creative menu while looking at a crafting table causes the crafting menu to display
@@ -4559,7 +4559,7 @@ bool mayUse = true;
 
 if(button==1 && (player->isSleeping() && level != NULL && level->isClientSide))
 {
-std::shared_ptr<MultiplayerLocalPlayer> mplp = dynamic_pointer_cast<MultiplayerLocalPlayer>( player );
+std::shared_ptr<MultiplayerLocalPlayer> mplp = std::dynamic_pointer_cast<MultiplayerLocalPlayer>( player );
 
 if(mplp) mplp->StopSleeping();
 
diff --git a/Minecraft.Client/MinecraftServer.cpp b/Minecraft.Client/MinecraftServer.cpp
index 0afd07397..83a987748 100644
--- a/Minecraft.Client/MinecraftServer.cpp
+++ b/Minecraft.Client/MinecraftServer.cpp
@@ -1291,7 +1291,7 @@ void MinecraftServer::run(__int64 seed, void *lpParameter)
 					{
 					std::shared_ptr<ServerPlayer> player = players->players.at(0);
 					eINSTANCEOF factory = (eINSTANCEOF)((size_t)param);
-					std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(factory,player->level ));
+					std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(factory,player->level ));
 					mob->moveTo(player->x+1, player->y, player->z+1, player->level->random->nextFloat() * 360, 0);
 					mob->setDespawnProtected();		// 4J added, default to being protected against despawning (has to be done after initial position is set)
 					player->level->addEntity(mob);
diff --git a/Minecraft.Client/Network/ClientConnection.cpp b/Minecraft.Client/Network/ClientConnection.cpp
index 21f282c87..506aedce7 100644
--- a/Minecraft.Client/Network/ClientConnection.cpp
+++ b/Minecraft.Client/Network/ClientConnection.cpp
@@ -446,7 +446,7 @@ void ClientConnection::handleAddEntity(std::shared_ptr<AddEntityPacket> packet)
 					}
 				}
 			}
-			std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(owner);
+			std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(owner);
 			if (player != NULL)
 			{
 				std::shared_ptr<FishingHook> hook = std::shared_ptr<FishingHook>( new FishingHook(level, x, y, z, player) );
@@ -547,7 +547,7 @@ void ClientConnection::handleAddEntity(std::shared_ptr<AddEntityPacket> packet)
 				}
 			}
 		}
-		std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(owner);
+		std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(owner);
 		if (player != NULL)
 		{
 			std::shared_ptr<FishingHook> hook = std::shared_ptr<FishingHook>( new FishingHook(level, x, y, z, player) );
@@ -653,9 +653,9 @@ void ClientConnection::handleAddEntity(std::shared_ptr<AddEntityPacket> packet)
 					}
 				}
 
-                if (dynamic_pointer_cast<Mob>(owner) != NULL)
+                if (std::dynamic_pointer_cast<Mob>(owner) != NULL)
 				{
-                    dynamic_pointer_cast<Arrow>(e)->owner = dynamic_pointer_cast<Mob>(owner);
+                    std::dynamic_pointer_cast<Arrow>(e)->owner = std::dynamic_pointer_cast<Mob>(owner);
                 }
             }
 
@@ -1201,7 +1201,7 @@ void ClientConnection::send(std::shared_ptr<Packet> packet)
 void ClientConnection::handleTakeItemEntity(std::shared_ptr<TakeItemEntityPacket> packet)
 {
     std::shared_ptr<Entity> from = getEntity(packet->itemId);
-    std::shared_ptr<Mob> to = dynamic_pointer_cast<Mob>(getEntity(packet->playerId));
+    std::shared_ptr<Mob> to = std::dynamic_pointer_cast<Mob>(getEntity(packet->playerId));
 
 	// 4J - the original game could assume that if getEntity didn't find the player, it must be the local player. We
 	// need to search all local players
@@ -1234,7 +1234,7 @@ void ClientConnection::handleTakeItemEntity(std::shared_ptr<TakeItemEntityPacket
 		// "from" reference if we've already removed the item for an earlier processed connection
 		if( isLocalPlayer )
 		{
-			std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>(to);
+			std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>(to);
 
 			// 4J Stu - Fix for #10213 - UI: Local clients cannot progress through the tutorial normally.
 			// We only send this packet once if many local players can see the event, so make sure we update
@@ -1565,7 +1565,7 @@ void ClientConnection::handleAnimate(std::shared_ptr<AnimatePacket> packet)
     if (e == NULL) return;
     if (packet->action == AnimatePacket::SWING)
 	{
-        std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
+        std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
         if(player != NULL) player->swing();
     }
 	else if (packet->action == AnimatePacket::HURT)
@@ -1574,7 +1574,7 @@ void ClientConnection::handleAnimate(std::shared_ptr<AnimatePacket> packet)
     }
 	else if (packet->action == AnimatePacket::WAKE_UP)
 	{
-        std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
+        std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
         if(player != NULL) player->stopSleepInBed(false, false, false);
     }
 	else if (packet->action == AnimatePacket::RESPAWN)
@@ -1592,7 +1592,7 @@ void ClientConnection::handleAnimate(std::shared_ptr<AnimatePacket> packet)
 		critParticle->CritParticlePostConstructor();
 		minecraft->particleEngine->add(critParticle);
     }
-	else if (packet->action == AnimatePacket::EAT && dynamic_pointer_cast<RemotePlayer>(e) != NULL)
+	else if (packet->action == AnimatePacket::EAT && std::dynamic_pointer_cast<RemotePlayer>(e) != NULL)
 	{
     }
 
@@ -1604,7 +1604,7 @@ void ClientConnection::handleEntityActionAtPosition(std::shared_ptr<EntityAction
     if (e == NULL) return;
     if (packet->action == EntityActionAtPositionPacket::START_SLEEP)
 	{
-        std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
+        std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
         player->startSleepInBed(packet->x, packet->y, packet->z);
 
 		if( player == minecraft->localplayers[m_userIndex] )
@@ -2110,7 +2110,7 @@ void ClientConnection::handleAddMob(std::shared_ptr<AddMobPacket> packet)
 	float yRot = packet->yRot * 360 / 256.0f;
 	float xRot = packet->xRot * 360 / 256.0f;
 
-	std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(EntityIO::newById(packet->type, level));
+	std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(EntityIO::newById(packet->type, level));
 	mob->xp = packet->x;
 	mob->yp = packet->y;
 	mob->zp = packet->z;
@@ -2150,7 +2150,7 @@ void ClientConnection::handleAddMob(std::shared_ptr<AddMobPacket> packet)
 	// 4J Stu - Slimes have a different BB depending on their size which is set in the entity data, so update the BB
 	if(mob->GetType() == eTYPE_SLIME || mob->GetType() == eTYPE_LAVASLIME)
 	{
-		std::shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(mob);
+		std::shared_ptr<Slime> slime = std::dynamic_pointer_cast<Slime>(mob);
 		slime->setSize( slime->getSize() );
 	}
 }
@@ -2173,7 +2173,7 @@ void ClientConnection::handleRidePacket(std::shared_ptr<SetRidingPacket> packet)
     std::shared_ptr<Entity> rider = getEntity(packet->riderId);
     std::shared_ptr<Entity> ridden = getEntity(packet->riddenId);
 
-	std::shared_ptr<Boat> boat = dynamic_pointer_cast<Boat>(ridden);
+	std::shared_ptr<Boat> boat = std::dynamic_pointer_cast<Boat>(ridden);
     //if (packet->riderId == minecraft->player->entityId) rider = minecraft->player;
 	if (packet->riderId == minecraft->localplayers[m_userIndex]->entityId)
 	{
@@ -2324,7 +2324,7 @@ void ClientConnection::handleTextureChange(std::shared_ptr<TextureChangePacket>
 {
 	std::shared_ptr<Entity> e = getEntity(packet->id);
     if (e == NULL) return;
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
 	if( e == NULL) return;
 
 	bool isLocalPlayer = false;
@@ -2379,7 +2379,7 @@ void ClientConnection::handleTextureAndGeometryChange(std::shared_ptr<TextureAnd
 {
 	std::shared_ptr<Entity> e = getEntity(packet->id);
 	if (e == NULL) return;
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
 	if( e == NULL) return;
 
 	bool isLocalPlayer = false;
@@ -2762,9 +2762,9 @@ void ClientConnection::handleSignUpdate(std::shared_ptr<SignUpdatePacket> packet
         std::shared_ptr<TileEntity> te = minecraft->level->getTileEntity(packet->x, packet->y, packet->z);
 
 		// 4J-PB - on a client connecting, the line below fails
-        if (dynamic_pointer_cast<SignTileEntity>(te) != NULL)
+        if (std::dynamic_pointer_cast<SignTileEntity>(te) != NULL)
 		{
-            std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>(te);
+            std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>(te);
             for (int i = 0; i < MAX_SIGN_LINES; i++)
 			{
 				ste->SetMessage(i,packet->lines[i]);
@@ -2778,7 +2778,7 @@ void ClientConnection::handleSignUpdate(std::shared_ptr<SignUpdatePacket> packet
         }
 		else
 		{
-			app.DebugPrintf("dynamic_pointer_cast<SignTileEntity>(te) == NULL\n");
+			app.DebugPrintf("std::dynamic_pointer_cast<SignTileEntity>(te) == NULL\n");
 		}
     }
 	else
@@ -2795,9 +2795,9 @@ void ClientConnection::handleTileEntityData(std::shared_ptr<TileEntityDataPacket
 
 		if (te != NULL)
 		{
-			if (packet->type == TileEntityDataPacket::TYPE_MOB_SPAWNER && dynamic_pointer_cast<MobSpawnerTileEntity>(te) != NULL)
+			if (packet->type == TileEntityDataPacket::TYPE_MOB_SPAWNER && std::dynamic_pointer_cast<MobSpawnerTileEntity>(te) != NULL)
 			{
-				dynamic_pointer_cast<MobSpawnerTileEntity>(te)->load(packet->tag);
+				std::dynamic_pointer_cast<MobSpawnerTileEntity>(te)->load(packet->tag);
 			}
 			//else if (packet.type == TileEntityDataPacket.TYPE_ADV_COMMAND && (te instanceof CommandBlockEntity))
 			//{
@@ -2807,9 +2807,9 @@ void ClientConnection::handleTileEntityData(std::shared_ptr<TileEntityDataPacket
 			//{
 			//	((BeaconTileEntity) te).load(packet.tag);
 			//} 
-			else if (packet->type == TileEntityDataPacket::TYPE_SKULL && dynamic_pointer_cast<SkullTileEntity>(te) != NULL)
+			else if (packet->type == TileEntityDataPacket::TYPE_SKULL && std::dynamic_pointer_cast<SkullTileEntity>(te) != NULL)
 			{
-				dynamic_pointer_cast<SkullTileEntity>(te)->load(packet->tag);
+				std::dynamic_pointer_cast<SkullTileEntity>(te)->load(packet->tag);
 			}
 		}
 	}
@@ -2968,17 +2968,17 @@ void ClientConnection::handleAwardStat(std::shared_ptr<AwardStatPacket> packet)
 void ClientConnection::handleUpdateMobEffect(std::shared_ptr<UpdateMobEffectPacket> packet)
 {
 	std::shared_ptr<Entity> e = getEntity(packet->entityId);
-	if (e == NULL || dynamic_pointer_cast<Mob>(e) == NULL) return;
+	if (e == NULL || std::dynamic_pointer_cast<Mob>(e) == NULL) return;
 
-	( dynamic_pointer_cast<Mob>(e) )->addEffect(new MobEffectInstance(packet->effectId, packet->effectDurationTicks, packet->effectAmplifier));
+	( std::dynamic_pointer_cast<Mob>(e) )->addEffect(new MobEffectInstance(packet->effectId, packet->effectDurationTicks, packet->effectAmplifier));
 }
 
 void ClientConnection::handleRemoveMobEffect(std::shared_ptr<RemoveMobEffectPacket> packet)
 {
 	std::shared_ptr<Entity> e = getEntity(packet->entityId);
-	if (e == NULL || dynamic_pointer_cast<Mob>(e) == NULL) return;
+	if (e == NULL || std::dynamic_pointer_cast<Mob>(e) == NULL) return;
 
-	( dynamic_pointer_cast<Mob>(e) )->removeEffectNoUpdate(packet->effectId);
+	( std::dynamic_pointer_cast<Mob>(e) )->removeEffectNoUpdate(packet->effectId);
 }
 
 bool ClientConnection::isServerPacketListener()
@@ -3005,7 +3005,7 @@ void ClientConnection::handlePlayerInfo(std::shared_ptr<PlayerInfoPacket> packet
 	std::shared_ptr<Entity> entity = getEntity(packet->m_entityId);
 	if(entity != NULL && entity->GetType() == eTYPE_PLAYER)
 	{
-		std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(entity);
+		std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(entity);
 		player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_All, packet->m_playerPrivileges);
 	}
 	if(networkPlayer != NULL && networkPlayer->IsLocal())
diff --git a/Minecraft.Client/Network/PlayerConnection.cpp b/Minecraft.Client/Network/PlayerConnection.cpp
index d16e8da47..18511aeec 100644
--- a/Minecraft.Client/Network/PlayerConnection.cpp
+++ b/Minecraft.Client/Network/PlayerConnection.cpp
@@ -1273,9 +1273,9 @@ void PlayerConnection::handleSignUpdate(std::shared_ptr<SignUpdatePacket> packet
 	{
 		std::shared_ptr<TileEntity> te = level->getTileEntity(packet->x, packet->y, packet->z);
 
-		if (dynamic_pointer_cast<SignTileEntity>(te) != NULL)
+		if (std::dynamic_pointer_cast<SignTileEntity>(te) != NULL)
 		{
-			std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>(te);
+			std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>(te);
 			if (!ste->isEditable())
 			{
 				server->warn(L"Player " + player->name + L" just tried to change non-editable sign");
@@ -1284,12 +1284,12 @@ void PlayerConnection::handleSignUpdate(std::shared_ptr<SignUpdatePacket> packet
 		}
 
 		// 4J-JEV: Changed to allow characters to display as a [].
-		if (dynamic_pointer_cast<SignTileEntity>(te) != NULL)
+		if (std::dynamic_pointer_cast<SignTileEntity>(te) != NULL)
 		{
 			int x = packet->x;
 			int y = packet->y;
 			int z = packet->z;
-			std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>(te);
+			std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>(te);
 			for (int i = 0; i < 4; i++)
 			{
 				std::wstring lineText = packet->lines[i].substr(0,15);
@@ -1512,7 +1512,7 @@ void PlayerConnection::handleCustomPayload(std::shared_ptr<CustomPayloadPacket>
 
 void PlayerConnection::handleDebugOptions(std::shared_ptr<DebugOptionsPacket> packet)
 {
-	//Player player = dynamic_pointer_cast<Player>( player->shared_from_this() );
+	//Player player = std::dynamic_pointer_cast<Player>( player->shared_from_this() );
 	player->SetDebugOptions(packet->m_uiVal);
 }
 
@@ -1528,7 +1528,7 @@ void PlayerConnection::handleCraftItem(std::shared_ptr<CraftItemPacket> packet)
 
 	if(app.DebugSettingsOn() && (player->GetDebugOptions()&(1L<<eDebugSetting_CraftAnything)))
 	{
-		pTempItemInst->onCraftedBy(player->level, dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count );
+		pTempItemInst->onCraftedBy(player->level, std::dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count );
 		if(player->inventory->add(pTempItemInst)==false )
 		{
 			// no room in inventory, so throw it down
@@ -1542,7 +1542,7 @@ void PlayerConnection::handleCraftItem(std::shared_ptr<CraftItemPacket> packet)
 	// TODO 4J Stu - Assume at the moment that the client can work this out for us...
 	//if(pRecipeIngredientsRequired[iRecipe].bCanMake) 
 	//{
-		pTempItemInst->onCraftedBy(player->level, dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count );
+		pTempItemInst->onCraftedBy(player->level, std::dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count );
 
 		// and remove those resources from your inventory
 		for(int i=0;i<pRecipeIngredientsRequired[iRecipe].iIngC;i++)
diff --git a/Minecraft.Client/Network/PlayerList.cpp b/Minecraft.Client/Network/PlayerList.cpp
index d6a0a0711..41aa62849 100644
--- a/Minecraft.Client/Network/PlayerList.cpp
+++ b/Minecraft.Client/Network/PlayerList.cpp
@@ -1037,7 +1037,7 @@ void PlayerList::broadcast(std::shared_ptr<Player> except, double x, double y, d
 	std::vector< std::shared_ptr<ServerPlayer> > sentTo;
 	if( except != NULL )
 	{
-		sentTo.push_back(dynamic_pointer_cast<ServerPlayer>(except));
+		sentTo.push_back(std::dynamic_pointer_cast<ServerPlayer>(except));
 	}
 
     for (unsigned int i = 0; i < players.size(); i++)
@@ -1080,7 +1080,7 @@ void PlayerList::broadcast(std::shared_ptr<Player> except, double x, double y, d
         if (xd * xd + yd * yd + zd * zd < range * range)
 		{
 #if 0 // _DEBUG
-			std::shared_ptr<LevelSoundPacket> SoundPacket= dynamic_pointer_cast<LevelSoundPacket>(packet);
+			std::shared_ptr<LevelSoundPacket> SoundPacket= std::dynamic_pointer_cast<LevelSoundPacket>(packet);
 
 			if(SoundPacket)
 			{
diff --git a/Minecraft.Client/Platform/PS3/PS3Extras/Ps3Types.h b/Minecraft.Client/Platform/PS3/PS3Extras/Ps3Types.h
index f163be259..f63513122 100644
--- a/Minecraft.Client/Platform/PS3/PS3Extras/Ps3Types.h
+++ b/Minecraft.Client/Platform/PS3/PS3Extras/Ps3Types.h
@@ -22,7 +22,7 @@
 
 using std::tr1::bad_std::;
 using std::tr1::const_pointer_cast;
-using std::tr1::dynamic_pointer_cast;
+using std::tr1::std::dynamic_pointer_cast;
 using std::tr1::enable_shared_from_this;
 using std::tr1::get_deleter;
 using std::tr1::std::shared_ptr;
diff --git a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/detail/intersegment_ptr.hpp b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/detail/intersegment_ptr.hpp
index ca2ff4acf..ff50267e6 100644
--- a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/detail/intersegment_ptr.hpp
+++ b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/detail/intersegment_ptr.hpp
@@ -886,7 +886,7 @@ boost::interprocess::intersegment_ptr<T> const_pointer_cast(const boost::interpr
 //!Simulation of dynamic_cast between pointers.
 //!Never throws.
 template<class T, class U> inline
-boost::interprocess::intersegment_ptr<T> dynamic_pointer_cast(const boost::interprocess::intersegment_ptr<U> &r)
+boost::interprocess::intersegment_ptr<T> std::dynamic_pointer_cast(const boost::interprocess::intersegment_ptr<U> &r)
 {  return boost::interprocess::intersegment_ptr<T>(r, boost::interprocess::ipcdetail::dynamic_cast_tag());  }
 
 //!Simulation of reinterpret_cast between pointers.
diff --git a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/offset_ptr.hpp b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/offset_ptr.hpp
index 752c43586..d2bec7179 100644
--- a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/offset_ptr.hpp
+++ b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/offset_ptr.hpp
@@ -602,7 +602,7 @@ inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
 //!Simulation of dynamic_cast between pointers. Never throws.
 template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
 inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
-   dynamic_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
+   std::dynamic_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
 {
    return boost::interprocess::offset_ptr<T1, P1, O1, A1>
             (r, boost::interprocess::ipcdetail::dynamic_cast_tag());
diff --git a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/smart_ptr/intrusive_ptr.hpp b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/smart_ptr/intrusive_ptr.hpp
index 897c5da4e..c366ef729 100644
--- a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/smart_ptr/intrusive_ptr.hpp
+++ b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/smart_ptr/intrusive_ptr.hpp
@@ -262,7 +262,7 @@ inline boost::interprocess::intrusive_ptr<T, VP> const_pointer_cast
 /*Emulates dynamic cast operator. Does not throw*/
 /*
 template<class T, class U, class VP>
-inline boost::interprocess::intrusive_ptr<T, VP> dynamic_pointer_cast
+inline boost::interprocess::intrusive_ptr<T, VP> std::dynamic_pointer_cast
    (boost::interprocess::intrusive_ptr<U, VP> const & p)
 {  return do_dynamic_cast<U>(p.get()); }
 */
diff --git a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/smart_ptr/shared_ptr.hpp b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/smart_ptr/shared_ptr.hpp
index 302eb149f..db4a78fec 100644
--- a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/smart_ptr/shared_ptr.hpp
+++ b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/smart_ptr/shared_ptr.hpp
@@ -341,7 +341,7 @@ shared_ptr<T, VoidAllocator, Deleter> const_pointer_cast(shared_ptr<U, VoidAlloc
 {  return shared_ptr<T, VoidAllocator, Deleter>(r, ipcdetail::const_cast_tag()); }
 
 template<class T, class VoidAllocator, class Deleter, class U> inline
-shared_ptr<T, VoidAllocator, Deleter> dynamic_pointer_cast(shared_ptr<U, VoidAllocator, Deleter> const & r)
+shared_ptr<T, VoidAllocator, Deleter> std::dynamic_pointer_cast(shared_ptr<U, VoidAllocator, Deleter> const & r)
 {  return shared_ptr<T, VoidAllocator, Deleter>(r, ipcdetail::dynamic_cast_tag());  }
 
 // to_raw_pointer() enables boost::mem_fn to recognize shared_ptr
diff --git a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/pointer_cast.hpp b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/pointer_cast.hpp
index 6e532ebdd..79ca37587 100644
--- a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/pointer_cast.hpp
+++ b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/pointer_cast.hpp
@@ -19,9 +19,9 @@ inline T* static_pointer_cast(U *ptr)
    return static_cast<T*>(ptr);
 }
 
-//dynamic_pointer_cast overload for raw pointers
+//std::dynamic_pointer_cast overload for raw pointers
 template<class T, class U>
-inline T* dynamic_pointer_cast(U *ptr)
+inline T* std::dynamic_pointer_cast(U *ptr)
 {  
    return dynamic_cast<T*>(ptr);
 }
diff --git a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/serialization/detail/shared_ptr_132.hpp b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/serialization/detail/shared_ptr_132.hpp
index b5f2b2156..a5b70f0a6 100644
--- a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/serialization/detail/shared_ptr_132.hpp
+++ b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/serialization/detail/shared_ptr_132.hpp
@@ -384,7 +384,7 @@ template<class T, class U> shared_ptr< T > const_pointer_cast(shared_ptr<U> cons
     return shared_ptr< T >(r, detail::const_cast_tag());
 }
 
-template<class T, class U> shared_ptr< T > dynamic_pointer_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr< T > std::dynamic_pointer_cast(shared_ptr<U> const & r)
 {
     return shared_ptr< T >(r, detail::dynamic_cast_tag());
 }
diff --git a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/smart_ptr/intrusive_ptr.hpp b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/smart_ptr/intrusive_ptr.hpp
index b6f5bcd53..83a3221d6 100644
--- a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/smart_ptr/intrusive_ptr.hpp
+++ b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/smart_ptr/intrusive_ptr.hpp
@@ -270,7 +270,7 @@ template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U>
     return const_cast<T *>(p.get());
 }
 
-template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
+template<class T, class U> intrusive_ptr<T> std::dynamic_pointer_cast(intrusive_ptr<U> const & p)
 {
     return dynamic_cast<T *>(p.get());
 }
diff --git a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/smart_ptr/shared_ptr.hpp b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/smart_ptr/shared_ptr.hpp
index 2f0ce7bcd..45e0c8597 100644
--- a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/smart_ptr/shared_ptr.hpp
+++ b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/smart_ptr/shared_ptr.hpp
@@ -805,7 +805,7 @@ template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const
     return shared_ptr<T>( r, p );
 }
 
-template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT 
+template<class T, class U> shared_ptr<T> std::dynamic_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT 
 {
     //(void) dynamic_cast< T* >( static_cast< U* >( 0 ) );	// // MGH - TODO - FIX - removed this check, as it was breaking the PS3 compile, and I've no idea why :-s
 
diff --git a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/tr1/memory.hpp b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/tr1/memory.hpp
index 169087746..3ec021348 100644
--- a/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/tr1/memory.hpp
+++ b/Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/tr1/memory.hpp
@@ -26,7 +26,7 @@ template<class T> class shared_ptr;
 template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) BOOST_NOEXCEPT;
 template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b) BOOST_NOEXCEPT;
 template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r) BOOST_NOEXCEPT;
-template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r) BOOST_NOEXCEPT;
+template<class T, class U> shared_ptr<T> std::dynamic_pointer_cast(shared_ptr<U> const & r) BOOST_NOEXCEPT;
 template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r) BOOST_NOEXCEPT;
 template<class D, class T> D * get_deleter(shared_ptr<T> const & p) BOOST_NOEXCEPT;
 template<class T> class enable_shared_from_this;
@@ -46,7 +46,7 @@ namespace std{ namespace tr1{
    using ::boost::swap;
 #endif
    using ::boost::static_pointer_cast;
-   using ::boost::dynamic_pointer_cast;
+   using ::boost::std::dynamic_pointer_cast;
    using ::boost::const_pointer_cast;
    using ::boost::get_deleter;
    using ::boost::weak_ptr;
diff --git a/Minecraft.Client/Player/EntityTracker.cpp b/Minecraft.Client/Player/EntityTracker.cpp
index 74985052b..0d219a34e 100644
--- a/Minecraft.Client/Player/EntityTracker.cpp
+++ b/Minecraft.Client/Player/EntityTracker.cpp
@@ -31,7 +31,7 @@ void EntityTracker::addEntity(std::shared_ptr<Entity> e)
     if (e->GetType() == eTYPE_SERVERPLAYER)
 	{
         addEntity(e, 32 * 16, 2);
-        std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e);
+        std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e);
 		for( AUTO_VAR(it, entities.begin()); it != entities.end(); it++ )
 		{
 			if( (*it)->e != player )
@@ -55,7 +55,7 @@ void EntityTracker::addEntity(std::shared_ptr<Entity> e)
     else if (e->GetType() == eTYPE_MINECART) addEntity(e, 16 * 5, 3, true);
     else if (e->GetType() == eTYPE_BOAT) addEntity(e, 16 * 5, 3, true);
     else if (e->GetType() == eTYPE_SQUID) addEntity(e, 16 * 4, 3, true);
-    else if (dynamic_pointer_cast<Creature>(e)!=NULL) addEntity(e, 16 * 5, 3, true);
+    else if (std::dynamic_pointer_cast<Creature>(e)!=NULL) addEntity(e, 16 * 5, 3, true);
 	else if (e->GetType() == eTYPE_ENDERDRAGON ) addEntity(e, 16 * 10, 3, true);
     else if (e->GetType() == eTYPE_PRIMEDTNT) addEntity(e, 16 * 10, 10, true);
     else if (e->GetType() == eTYPE_FALLINGTILE) addEntity(e, 16 * 10, 20, true);
@@ -105,7 +105,7 @@ void EntityTracker::removePlayer(std::shared_ptr<Entity> e)
 {
     if (e->GetType() == eTYPE_SERVERPLAYER)
 	{
-        std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e);
+        std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e);
 		for( AUTO_VAR(it, entities.begin()); it != entities.end(); it++ )
 		{
 			(*it)->removePlayer(player);
@@ -122,7 +122,7 @@ void EntityTracker::tick()
         te->tick(this, &level->players);
         if (te->moved && te->e->GetType() == eTYPE_SERVERPLAYER)
 		{
-            movedPlayers.push_back(dynamic_pointer_cast<ServerPlayer>(te->e));
+            movedPlayers.push_back(std::dynamic_pointer_cast<ServerPlayer>(te->e));
         }
 	}
 
@@ -174,7 +174,7 @@ void EntityTracker::tick()
 	// 4J Stu - We want to do this for dead players as they don't tick normally
 	for(AUTO_VAR(it, level->players.begin()); it != level->players.end(); ++it)
 	{
-        std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(*it);
+        std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(*it);
 		if(!player->isAlive())
 		{
 			player->flushEntitiesToRemove();
diff --git a/Minecraft.Client/Player/LocalPlayer.cpp b/Minecraft.Client/Player/LocalPlayer.cpp
index b2cc5e648..11665ff0c 100644
--- a/Minecraft.Client/Player/LocalPlayer.cpp
+++ b/Minecraft.Client/Player/LocalPlayer.cpp
@@ -276,7 +276,7 @@ void LocalPlayer::aiStep()
 	float runTreshold = 0.8f;
 
 	bool wasRunning = input->ya >= runTreshold;
-	//input->tick( dynamic_pointer_cast<Player>( shared_from_this() ) );
+	//input->tick( std::dynamic_pointer_cast<Player>( shared_from_this() ) );
 	// 4J-PB - make it a localplayer
 	input->tick( this );
 	if (isUsingItem())
@@ -600,7 +600,7 @@ bool LocalPlayer::openContainer(std::shared_ptr<Container> container)
 
 bool LocalPlayer::startCrafting(int x, int y, int z)
 {
-	bool success = app.LoadCrafting3x3Menu(GetXboxPad(), dynamic_pointer_cast<LocalPlayer>( shared_from_this() ), x, y, z );
+	bool success = app.LoadCrafting3x3Menu(GetXboxPad(), std::dynamic_pointer_cast<LocalPlayer>( shared_from_this() ), x, y, z );
 	if( success ) ui.PlayUISFX(eSFX_Press);
 	//app.LoadXuiCraftMenu(0,inventory, level, x, y, z);
 	//minecraft->setScreen(new CraftingScreen(inventory, level, x, y, z));
@@ -744,7 +744,7 @@ void LocalPlayer::awardStat(Stat *stat, byteArray param)
 			&& ProfileManager.IsFullVersion()
 		)
 	{
-		stat->handleParamBlob(dynamic_pointer_cast<LocalPlayer>(shared_from_this()), param);
+		stat->handleParamBlob(std::dynamic_pointer_cast<LocalPlayer>(shared_from_this()), param);
 	}
 	delete [] param.data;
 #else
@@ -1408,7 +1408,7 @@ bool LocalPlayer::handleMouseClick(int button)
 		if(lastClickState == lastClick_oldRepeat) return false;
 
 
-		std::shared_ptr<MultiplayerLocalPlayer> mplp = dynamic_pointer_cast<MultiplayerLocalPlayer>( shared_from_this() );
+		std::shared_ptr<MultiplayerLocalPlayer> mplp = std::dynamic_pointer_cast<MultiplayerLocalPlayer>( shared_from_this() );
 
 		if(mplp && mplp->connection) mplp->StopSleeping();
 	
@@ -1528,15 +1528,15 @@ void LocalPlayer::updateRichPresence()
 		{
 			app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_MAP);
 		}	
-		else if(riding != NULL && dynamic_pointer_cast<Minecart>(riding) != NULL)
+		else if(riding != NULL && std::dynamic_pointer_cast<Minecart>(riding) != NULL)
 		{
 			app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_RIDING_MINECART);
 		}
-		else if(riding != NULL && dynamic_pointer_cast<Boat>(riding) != NULL)
+		else if(riding != NULL && std::dynamic_pointer_cast<Boat>(riding) != NULL)
 		{
 			app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_BOATING);
 		}
-		else if(riding != NULL && dynamic_pointer_cast<Pig>(riding) != NULL)
+		else if(riding != NULL && std::dynamic_pointer_cast<Pig>(riding) != NULL)
 		{
 			app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_RIDING_PIG);
 		}
diff --git a/Minecraft.Client/Player/MultiPlayerLocalPlayer.cpp b/Minecraft.Client/Player/MultiPlayerLocalPlayer.cpp
index 50deaa970..d62ff2ae6 100644
--- a/Minecraft.Client/Player/MultiPlayerLocalPlayer.cpp
+++ b/Minecraft.Client/Player/MultiPlayerLocalPlayer.cpp
@@ -334,9 +334,9 @@ void MultiplayerLocalPlayer::ride(std::shared_ptr<Entity> e)
 		}
 		else if (!wasRiding && isRiding)
 		{
-			if(dynamic_pointer_cast<Minecart>(e) != NULL)
+			if(std::dynamic_pointer_cast<Minecart>(e) != NULL)
 				gameMode->getTutorial()->changeTutorialState(e_Tutorial_State_Riding_Minecart);
-			else if(dynamic_pointer_cast<Boat>(e) != NULL)
+			else if(std::dynamic_pointer_cast<Boat>(e) != NULL)
 				gameMode->getTutorial()->changeTutorialState(e_Tutorial_State_Riding_Boat);
 		}
 	}
diff --git a/Minecraft.Client/Player/ServerPlayer.cpp b/Minecraft.Client/Player/ServerPlayer.cpp
index e459ebd9c..0ac82bf3d 100644
--- a/Minecraft.Client/Player/ServerPlayer.cpp
+++ b/Minecraft.Client/Player/ServerPlayer.cpp
@@ -293,7 +293,7 @@ void ServerPlayer::doTickA()
 			// particularly at the start of a game. They don't typically seem to be massive and shouldn't be send when there isn't actually any updating to do.
             if (Item::items[ie->id]->isComplex() ) // && connection->countDelayedPackets() <= 2)
 			{
-                std::shared_ptr<Packet> packet = (dynamic_cast<ComplexItem *>(Item::items[ie->id])->getUpdatePacket(ie, level, dynamic_pointer_cast<Player>( shared_from_this() ) ) );
+                std::shared_ptr<Packet> packet = (dynamic_cast<ComplexItem *>(Item::items[ie->id])->getUpdatePacket(ie, level, std::dynamic_pointer_cast<Player>( shared_from_this() ) ) );
                 if (packet != NULL)
 				{
                     connection->send(packet);
@@ -474,7 +474,7 @@ void ServerPlayer::doTickB(bool ignorePortal)
 // 	{
 // 		if(level->dimension->id == 0 )
 // 		{		
-// 			server->players->toggleDimension( dynamic_pointer_cast<ServerPlayer>( shared_from_this() ), 1 );
+// 			server->players->toggleDimension( std::dynamic_pointer_cast<ServerPlayer>( shared_from_this() ), 1 );
 // 		}
 // 		unsigned int uiVal=app.GetGameSettingsDebugMask(ProfileManager.GetPrimaryPad());
 // 		app.SetGameSettingsDebugMask(ProfileManager.GetPrimaryPad(),uiVal&~(1L<<eDebugSetting_GoToEnd));
@@ -519,7 +519,7 @@ void ServerPlayer::doTickB(bool ignorePortal)
 						if (dimension == -1) targetDimension = 0;
 						else targetDimension = -1;
 
-						server->getPlayers()->toggleDimension( dynamic_pointer_cast<ServerPlayer>( shared_from_this() ), targetDimension );
+						server->getPlayers()->toggleDimension( std::dynamic_pointer_cast<ServerPlayer>( shared_from_this() ), targetDimension );
 						lastSentExp = -1;
 						lastSentHealth = -1;
 						lastSentFood = -1;
@@ -563,7 +563,7 @@ std::shared_ptr<ItemInstance> ServerPlayer::getCarried(int slot)
 
 void ServerPlayer::die(DamageSource *source)
 {
-	server->getPlayers()->broadcastAll(source->getDeathMessagePacket(dynamic_pointer_cast<Player>(shared_from_this())));
+	server->getPlayers()->broadcastAll(source->getDeathMessagePacket(std::dynamic_pointer_cast<Player>(shared_from_this())));
 	inventory->dropAll();
 }
 
@@ -578,15 +578,15 @@ bool ServerPlayer::hurt(DamageSource *dmgSource, int dmg)
 		std::shared_ptr<Entity> source = dmgSource->getDirectEntity();
 
 		
-		if (dynamic_pointer_cast<Player>(source) != NULL &&	(!server->pvp || !dynamic_pointer_cast<Player>(source)->isAllowedToAttackPlayers()) )
+		if (std::dynamic_pointer_cast<Player>(source) != NULL &&	(!server->pvp || !std::dynamic_pointer_cast<Player>(source)->isAllowedToAttackPlayers()) )
 		{
 			return false;
 		}
 
 		if (source != NULL && source->GetType() == eTYPE_ARROW)
 		{
-			std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(source);
-			if (dynamic_pointer_cast<Player>(arrow->owner) != NULL && (!server->pvp || !dynamic_pointer_cast<Player>(arrow->owner)->isAllowedToAttackPlayers()) )
+			std::shared_ptr<Arrow> arrow = std::dynamic_pointer_cast<Arrow>(source);
+			if (std::dynamic_pointer_cast<Player>(arrow->owner) != NULL && (!server->pvp || !std::dynamic_pointer_cast<Player>(arrow->owner)->isAllowedToAttackPlayers()) )
 			{
 				return false;
 			}
@@ -645,9 +645,9 @@ bool ServerPlayer::hurt(DamageSource *dmgSource, int dmg)
 					m_lastDamageSource = eTelemetryPlayerDeathSource_Explosion_Tnt;
 					break;
 				case eTYPE_ARROW:
-					if ((dynamic_pointer_cast<Arrow>(source))->owner != NULL)
+					if ((std::dynamic_pointer_cast<Arrow>(source))->owner != NULL)
 						{
-						std::shared_ptr<Entity> attacker = (dynamic_pointer_cast<Arrow>(source))->owner;
+						std::shared_ptr<Entity> attacker = (std::dynamic_pointer_cast<Arrow>(source))->owner;
 						if (attacker != NULL)
 						{
 							switch(attacker->GetType())
@@ -725,7 +725,7 @@ void ServerPlayer::changeDimension(int i)
 			connection->teleport(pos->x, pos->y, pos->z, 0, 0);
 			delete pos;
 		}
-		server->getPlayers()->toggleDimension( dynamic_pointer_cast<ServerPlayer>(shared_from_this()), 1);
+		server->getPlayers()->toggleDimension( std::dynamic_pointer_cast<ServerPlayer>(shared_from_this()), 1);
 		lastSentExp = -1;
 		lastSentHealth = -1;
 		lastSentFood = -1;
@@ -869,7 +869,7 @@ bool ServerPlayer::startRepairing(int x, int y, int z)
 	{
 		nextContainerCounter();
 		connection->send(std::shared_ptr<ContainerOpenPacket> ( new ContainerOpenPacket(containerCounter, ContainerOpenPacket::REPAIR_TABLE, 0, 9)) );
-		containerMenu = new RepairMenu(inventory, level, x, y, z, dynamic_pointer_cast<Player>(shared_from_this()));
+		containerMenu = new RepairMenu(inventory, level, x, y, z, std::dynamic_pointer_cast<Player>(shared_from_this()));
 		containerMenu->containerId = containerCounter;
 		containerMenu->addSlotListener(this);
 	}
@@ -966,7 +966,7 @@ bool ServerPlayer::openTrading(std::shared_ptr<Merchant> traderTarget)
 
 		connection->send(std::shared_ptr<ContainerOpenPacket>(new ContainerOpenPacket(containerCounter, ContainerOpenPacket::TRADER_NPC, container->getName(), container->getContainerSize())));
 
-		MerchantRecipeList *offers = traderTarget->getOffers(dynamic_pointer_cast<Player>(shared_from_this()));
+		MerchantRecipeList *offers = traderTarget->getOffers(std::dynamic_pointer_cast<Player>(shared_from_this()));
 		if (offers != NULL)
 		{
 				ByteArrayOutputStream rawOutput;
@@ -1057,7 +1057,7 @@ void ServerPlayer::broadcastCarriedItem()
 
 void ServerPlayer::doCloseContainer()
 {
-    containerMenu->removed( dynamic_pointer_cast<Player>( shared_from_this() ) );
+    containerMenu->removed( std::dynamic_pointer_cast<Player>( shared_from_this() ) );
     containerMenu = inventoryMenu;
 }
 
@@ -1368,7 +1368,7 @@ void ServerPlayer::restoreFrom(std::shared_ptr<Player> oldPlayer, bool restoreAl
 	lastSentExp = -1;
 	lastSentHealth = -1;
 	lastSentFood = -1;
-	entitiesToRemove = dynamic_pointer_cast<ServerPlayer>(oldPlayer)->entitiesToRemove;
+	entitiesToRemove = std::dynamic_pointer_cast<ServerPlayer>(oldPlayer)->entitiesToRemove;
 }
 
 void ServerPlayer::onEffectAdded(MobEffectInstance *effect)
@@ -1430,7 +1430,7 @@ void ServerPlayer::sendMessage(const std::wstring& message, ChatPacket::EChatPac
 
 bool ServerPlayer::hasPermission(EGameCommand command)
 {
-	return server->getPlayers()->isOp(dynamic_pointer_cast<ServerPlayer>(shared_from_this()));
+	return server->getPlayers()->isOp(std::dynamic_pointer_cast<ServerPlayer>(shared_from_this()));
 }
 
 // 4J - Don't use
diff --git a/Minecraft.Client/Player/ServerPlayerGameMode.cpp b/Minecraft.Client/Player/ServerPlayerGameMode.cpp
index 4456dbc7e..eee12430f 100644
--- a/Minecraft.Client/Player/ServerPlayerGameMode.cpp
+++ b/Minecraft.Client/Player/ServerPlayerGameMode.cpp
@@ -247,7 +247,7 @@ bool ServerPlayerGameMode::destroyBlock(int x, int y, int z)
 	if( isCreative() )
 	{
 		clientToUpdateRenderer = true;
-		if( dynamic_pointer_cast<ServerPlayer>(player)->connection->isLocal() )
+		if( std::dynamic_pointer_cast<ServerPlayer>(player)->connection->isLocal() )
 		{
 			// Establish whether we are sharing this chunk between client & server
 			MultiPlayerLevel *clientLevel = Minecraft::GetInstance()->getLevel(level->dimension->id);
diff --git a/Minecraft.Client/Player/TrackedEntity.cpp b/Minecraft.Client/Player/TrackedEntity.cpp
index 91a63c017..3d456f6b3 100644
--- a/Minecraft.Client/Player/TrackedEntity.cpp
+++ b/Minecraft.Client/Player/TrackedEntity.cpp
@@ -70,7 +70,7 @@ void TrackedEntity::tick(EntityTracker *tracker, std::vector<std::shared_ptr<Pla
 	// Moving forward  special case for item frames
 	if (e->GetType()== eTYPE_ITEM_FRAME && tickCount % 10 == 0) 
 	{
-		std::shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame> (e);
+		std::shared_ptr<ItemFrame> frame = std::dynamic_pointer_cast<ItemFrame> (e);
 		std::shared_ptr<ItemInstance> item = frame->getItem();
 
 		if (item != NULL && item->getItem()->id == Item::map_Id && !e->removed) 
@@ -78,7 +78,7 @@ void TrackedEntity::tick(EntityTracker *tracker, std::vector<std::shared_ptr<Pla
  			std::shared_ptr<MapItemSavedData> data = Item::map->getSavedData(item, e->level);
  			for (AUTO_VAR(it,players->begin() ); it != players->end(); ++it)
 			{
- 				std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(*it);
+ 				std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(*it);
  				data->tickCarriedBy(player, item);
  
  				if (!player->removed && player->connection && player->connection->countDelayedPackets() <= 5) 
@@ -278,7 +278,7 @@ void TrackedEntity::tick(EntityTracker *tracker, std::vector<std::shared_ptr<Pla
 					xRotp = xRotn;
 				}
 
-				//		if( dynamic_pointer_cast<ServerPlayer>(e) != NULL )
+				//		if( std::dynamic_pointer_cast<ServerPlayer>(e) != NULL )
 				//		{
 				//			printf("%d: %d + %d = %d (%f)\n",e->entityId,xRotp,xRota,xRotn,e->xRot);
 				//		}
@@ -337,7 +337,7 @@ void TrackedEntity::broadcast(std::shared_ptr<Packet> packet)
 						{
 							dontSend = true;
 		// #ifdef _DEBUG
-		// 					std::shared_ptr<SetEntityMotionPacket> emp= dynamic_pointer_cast<SetEntityMotionPacket> (packet);
+		// 					std::shared_ptr<SetEntityMotionPacket> emp= std::dynamic_pointer_cast<SetEntityMotionPacket> (packet);
 		// 					if(emp!=NULL)
 		// 					{
 		// 						app.DebugPrintf("Not sending this SetEntityMotionPacket to player - it's already been sent to a player on their console\n");
@@ -372,7 +372,7 @@ void TrackedEntity::broadcastAndSend(std::shared_ptr<Packet> packet)
 {
 	std::vector< std::shared_ptr<ServerPlayer> > sentTo;
     broadcast(packet);
-	std::shared_ptr<ServerPlayer> sp = dynamic_pointer_cast<ServerPlayer>(e);
+	std::shared_ptr<ServerPlayer> sp = std::dynamic_pointer_cast<ServerPlayer>(e);
 	if (sp != NULL && sp->connection)
 	{
         sp->connection->send(packet);
@@ -480,7 +480,7 @@ void TrackedEntity::updatePlayer(EntityTracker *tracker, std::shared_ptr<ServerP
 		yap = e->yd;
 		zap = e->zd;
 
-		std::shared_ptr<Player> plr = dynamic_pointer_cast<Player>(e);
+		std::shared_ptr<Player> plr = std::dynamic_pointer_cast<Player>(e);
 		if (plr != NULL)
 		{
 			app.DebugPrintf( "TrackedEntity:: Player '%ls' is now visible to player '%ls', %s.\n",
@@ -490,7 +490,7 @@ void TrackedEntity::updatePlayer(EntityTracker *tracker, std::shared_ptr<ServerP
 		}
 
 		// 4J Stu brought forward to fix when Item Frames
-		if (!e->getEntityData()->isEmpty() && !(dynamic_pointer_cast<AddMobPacket>(packet)))
+		if (!e->getEntityData()->isEmpty() && !(std::dynamic_pointer_cast<AddMobPacket>(packet)))
 		{
 			sp->connection->send(std::shared_ptr<SetEntityDataPacket>( new SetEntityDataPacket(e->entityId, e->getEntityData(), true)));
 		}
@@ -514,18 +514,18 @@ void TrackedEntity::updatePlayer(EntityTracker *tracker, std::shared_ptr<ServerP
             }
         }
 
-        if (dynamic_pointer_cast<Player>(e) != NULL)
+        if (std::dynamic_pointer_cast<Player>(e) != NULL)
 		{
-            std::shared_ptr<Player> spe = dynamic_pointer_cast<Player>(e);
+            std::shared_ptr<Player> spe = std::dynamic_pointer_cast<Player>(e);
             if (spe->isSleeping())
 			{
                 sp->connection->send( std::shared_ptr<EntityActionAtPositionPacket>( new EntityActionAtPositionPacket(e, EntityActionAtPositionPacket::START_SLEEP, Mth::floor(e->x), Mth::floor(e->y), Mth::floor(e->z)) ) );
             }
         }
 
-		if (dynamic_pointer_cast<Mob>(e) != NULL)
+		if (std::dynamic_pointer_cast<Mob>(e) != NULL)
 		{
-			std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e);
+			std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(e);
 			std::vector<MobEffectInstance *> *activeEffects = mob->getActiveEffects();
 			for(AUTO_VAR(it, activeEffects->begin()); it != activeEffects->end(); ++it)
 			{
@@ -562,7 +562,7 @@ void TrackedEntity::updatePlayers(EntityTracker *tracker, std::vector<std::share
 {
     for (unsigned int i = 0; i < players->size(); i++)
 	{
-        updatePlayer(tracker, dynamic_pointer_cast<ServerPlayer>( players->at(i) ) );
+        updatePlayer(tracker, std::dynamic_pointer_cast<ServerPlayer>( players->at(i) ) );
     }
 }
 
@@ -574,10 +574,10 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 	}
 
 	// 4J-PB - replacing with a switch, rather than tons of ifs
-	if (dynamic_pointer_cast<Creature>(e) != NULL)
+	if (std::dynamic_pointer_cast<Creature>(e) != NULL)
 	{
 		yHeadRotp = Mth::floor(e->getYHeadRot() * 256 / 360);
-		return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp) );
+		return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp) );
 	}
 
 	switch(e->GetType())
@@ -590,7 +590,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 		break;
 	case eTYPE_SERVERPLAYER:
 		{
-			std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e);
+			std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e);
 			PlayerUID xuid = INVALID_XUID;
 			PlayerUID OnlineXuid = INVALID_XUID;
 			if( player != NULL )
@@ -599,12 +599,12 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 				OnlineXuid = player->getOnlineXuid();
 			}
 			// 4J Added yHeadRotp param to fix #102563 - TU12: Content: Gameplay: When one of the Players is idle for a few minutes his head turns 180 degrees.
-			return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp, yHeadRotp ) );
+			return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(std::dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp, yHeadRotp ) );
 		}
 		break;
 	case eTYPE_MINECART:
 		{
-			std::shared_ptr<Minecart> minecart = dynamic_pointer_cast<Minecart>(e);
+			std::shared_ptr<Minecart> minecart = std::dynamic_pointer_cast<Minecart>(e);
 			if (minecart->type == Minecart::RIDEABLE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_RIDEABLE, yRotp, xRotp, xp, yp, zp) );
 			if (minecart->type == Minecart::CHEST) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_CHEST, yRotp, xRotp, xp, yp, zp) );
 			if (minecart->type == Minecart::FURNACE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_FURNACE, yRotp, xRotp, xp, yp, zp) );
@@ -618,18 +618,18 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 	case eTYPE_ENDERDRAGON:
 		{
 			yHeadRotp = Mth::floor(e->getYHeadRot() * 256 / 360);
-			return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp ) );
+			return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp ) );
 		}
 		break;
 	case eTYPE_FISHINGHOOK:
 		{
-			std::shared_ptr<Entity> owner = dynamic_pointer_cast<FishingHook>(e)->owner;
+			std::shared_ptr<Entity> owner = std::dynamic_pointer_cast<FishingHook>(e)->owner;
 			return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FISH_HOOK, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
 		}
 		break;
 	case eTYPE_ARROW:
 		{
-			std::shared_ptr<Entity> owner = (dynamic_pointer_cast<Arrow>(e))->owner;
+			std::shared_ptr<Entity> owner = (std::dynamic_pointer_cast<Arrow>(e))->owner;
 			return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ARROW, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
 		}
 		break;
@@ -640,7 +640,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 		break;
 	case eTYPE_THROWNPOTION:
 		{
-			return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp));
+			return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((std::dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp));
 		}
 		break;
 	case eTYPE_THROWNEXPBOTTLE:
@@ -660,7 +660,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 		break;
 	case eTYPE_SMALL_FIREBALL:
 		{
-			std::shared_ptr<SmallFireball> fb = dynamic_pointer_cast<SmallFireball>(e);
+			std::shared_ptr<SmallFireball> fb = std::dynamic_pointer_cast<SmallFireball>(e);
 			std::shared_ptr<AddEntityPacket> aep = nullptr;
 			if (fb->owner != NULL)
 			{
@@ -678,7 +678,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 		break;
 	case eTYPE_DRAGON_FIREBALL:
 		{
-			std::shared_ptr<DragonFireball> fb = dynamic_pointer_cast<DragonFireball>(e);
+			std::shared_ptr<DragonFireball> fb = std::dynamic_pointer_cast<DragonFireball>(e);
 			std::shared_ptr<AddEntityPacket> aep = nullptr;
 			if (fb->owner != NULL)
 			{
@@ -696,7 +696,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 		break;
 	case eTYPE_FIREBALL:
 		{
-			std::shared_ptr<Fireball> fb = dynamic_pointer_cast<Fireball>(e);
+			std::shared_ptr<Fireball> fb = std::dynamic_pointer_cast<Fireball>(e);
 			std::shared_ptr<AddEntityPacket> aep = nullptr;
 			if (fb->owner != NULL)
 			{
@@ -729,18 +729,18 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 		break;
 	case eTYPE_FALLINGTILE:
 		{
-			std::shared_ptr<FallingTile> ft = dynamic_pointer_cast<FallingTile>(e);
+			std::shared_ptr<FallingTile> ft = std::dynamic_pointer_cast<FallingTile>(e);
             return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING, ft->tile | (ft->data << 16), yRotp, xRotp, xp, yp, zp) );
 		}
 		break;
 	case eTYPE_PAINTING:
 		{
-			return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(dynamic_pointer_cast<Painting>(e)) );
+			return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(std::dynamic_pointer_cast<Painting>(e)) );
 		}
 		break;
 	case eTYPE_ITEM_FRAME:
 		{
-			std::shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame>(e);
+			std::shared_ptr<ItemFrame> frame = std::dynamic_pointer_cast<ItemFrame>(e);
 			{
 
 				int ix= (int)frame->xTile;
@@ -758,7 +758,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 		break;
 	case eTYPE_EXPERIENCEORB:
 		{
-			return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(dynamic_pointer_cast<ExperienceOrb>(e)) );
+			return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(std::dynamic_pointer_cast<ExperienceOrb>(e)) );
 		}
 		break;
 	default:
@@ -768,7 +768,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 /*
 	if (e->GetType() == eTYPE_ITEMENTITY)
 	{
-		std::shared_ptr<ItemEntity> itemEntity = dynamic_pointer_cast<ItemEntity>(e);
+		std::shared_ptr<ItemEntity> itemEntity = std::dynamic_pointer_cast<ItemEntity>(e);
         std::shared_ptr<AddItemEntityPacket> packet = std::shared_ptr<AddItemEntityPacket>( new AddItemEntityPacket(itemEntity, xp, yp, zp) );
         itemEntity->x = packet->x / 32.0;
         itemEntity->y = packet->y / 32.0;
@@ -778,7 +778,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 
     if (e->GetType() == eTYPE_SERVERPLAYER )
 	{
-		std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e);
+		std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e);
 		XUID xuid = INVALID_XUID;
 		XUID OnlineXuid = INVALID_XUID;
 		if( player != NULL )
@@ -786,11 +786,11 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 			xuid = player->getXuid();
 			OnlineXuid = player->getOnlineXuid();
 		}
-		return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp ) );
+		return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(std::dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp ) );
     }
     if (e->GetType() == eTYPE_MINECART)
 	{
-        std::shared_ptr<Minecart> minecart = dynamic_pointer_cast<Minecart>(e);
+        std::shared_ptr<Minecart> minecart = std::dynamic_pointer_cast<Minecart>(e);
         if (minecart->type == Minecart::RIDEABLE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_RIDEABLE, yRotp, xRotp, xp, yp, zp) );
         if (minecart->type == Minecart::CHEST) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_CHEST, yRotp, xRotp, xp, yp, zp) );
         if (minecart->type == Minecart::FURNACE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_FURNACE, yRotp, xRotp, xp, yp, zp) );
@@ -799,22 +799,22 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 	{
         return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::BOAT, yRotp, xRotp, xp, yp, zp) );
     }
-    if (dynamic_pointer_cast<Creature>(e) != NULL)
+    if (std::dynamic_pointer_cast<Creature>(e) != NULL)
 	{
-        return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp) );
+        return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp) );
     }
 	if (e->GetType() == eTYPE_ENDERDRAGON)
 	{
-		return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp ) );
+		return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp ) );
 	}
 	if (e->GetType() == eTYPE_FISHINGHOOK)
 	{
-		std::shared_ptr<Entity> owner = dynamic_pointer_cast<FishingHook>(e)->owner;
+		std::shared_ptr<Entity> owner = std::dynamic_pointer_cast<FishingHook>(e)->owner;
 		return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FISH_HOOK, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
     }
     if (e->GetType() == eTYPE_ARROW)
 	{
-        std::shared_ptr<Entity> owner = (dynamic_pointer_cast<Arrow>(e))->owner;
+        std::shared_ptr<Entity> owner = (std::dynamic_pointer_cast<Arrow>(e))->owner;
         return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ARROW, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
     }
 	if (e->GetType() == eTYPE_SNOWBALL)
@@ -823,7 +823,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
     }
 	if (e->GetType() == eTYPE_THROWNPOTION)
 	{
-		return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp));
+		return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((std::dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp));
 	}
 	if (e->GetType() == eTYPE_THROWNEXPBOTTLE)
 	{
@@ -839,7 +839,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 	}
 	if (e->GetType() == eTYPE_SMALL_FIREBALL)
 	{
-		std::shared_ptr<SmallFireball> fb = dynamic_pointer_cast<SmallFireball>(e);
+		std::shared_ptr<SmallFireball> fb = std::dynamic_pointer_cast<SmallFireball>(e);
 		std::shared_ptr<AddEntityPacket> aep = NULL;
 		if (fb->owner != NULL)
 		{
@@ -856,7 +856,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 	}
 	if (e->GetType() == eTYPE_FIREBALL)
 	{
-        std::shared_ptr<Fireball> fb = dynamic_pointer_cast<Fireball>(e);
+        std::shared_ptr<Fireball> fb = std::dynamic_pointer_cast<Fireball>(e);
 		std::shared_ptr<AddEntityPacket> aep = NULL;
 		if (fb->owner != NULL)
 		{
@@ -885,18 +885,18 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 	}
 	if (e->GetType() == eTYPE_FALLINGTILE)
 	{
-        std::shared_ptr<FallingTile> ft = dynamic_pointer_cast<FallingTile>(e);
+        std::shared_ptr<FallingTile> ft = std::dynamic_pointer_cast<FallingTile>(e);
         if (ft->tile == Tile::sand_Id) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_SAND, yRotp, xRotp, xp, yp, zp) );
         if (ft->tile == Tile::gravel_Id) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_GRAVEL, yRotp, xRotp, xp, yp, zp) );
 		if (ft->tile == Tile::dragonEgg_Id) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_EGG, yRotp, xRotp, xp, yp, zp) );
     }
 	if (e->GetType() == eTYPE_PAINTING)
 	{
-        return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(dynamic_pointer_cast<Painting>(e)) );
+        return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(std::dynamic_pointer_cast<Painting>(e)) );
     }
 	if (e->GetType() == eTYPE_ITEM_FRAME) 
 	{
-		std::shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame>(e);
+		std::shared_ptr<ItemFrame> frame = std::dynamic_pointer_cast<ItemFrame>(e);
 		{
 
 			int ix= (int)frame->xTile;
@@ -913,7 +913,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
 	}
 	if (e->GetType() == eTYPE_EXPERIENCEORB)
 	{
-        return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(dynamic_pointer_cast<ExperienceOrb>(e)) );
+        return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(std::dynamic_pointer_cast<ExperienceOrb>(e)) );
     }
 	assert(false);
 	*/
diff --git a/Minecraft.Client/Rendering/EntityRenderers/ArrowRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/ArrowRenderer.cpp
index df7ff6d02..408725c24 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/ArrowRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/ArrowRenderer.cpp
@@ -7,7 +7,7 @@ void ArrowRenderer::render(std::shared_ptr<Entity> _arrow, double x, double y, d
 {
 	// 4J - original version used generics and thus had an input parameter of type Arrow rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(_arrow);
+	std::shared_ptr<Arrow> arrow = std::dynamic_pointer_cast<Arrow>(_arrow);
     bindTexture(TN_ITEM_ARROWS); // 4J - was L"/item/arrows.png"
 
     glPushMatrix();
diff --git a/Minecraft.Client/Rendering/EntityRenderers/BlazeRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/BlazeRenderer.cpp
index 8e3119265..cafe47861 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/BlazeRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/BlazeRenderer.cpp
@@ -12,7 +12,7 @@ void BlazeRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, dou
 {
 	// 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<Blaze> mob = dynamic_pointer_cast<Blaze>(_mob);
+	std::shared_ptr<Blaze> mob = std::dynamic_pointer_cast<Blaze>(_mob);
 
 	int modelVersion = ((BlazeModel *) model)->modelVersion();
 	if (modelVersion != this->modelVersion)
diff --git a/Minecraft.Client/Rendering/EntityRenderers/BoatRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/BoatRenderer.cpp
index 3b4c3823b..2a9fba093 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/BoatRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/BoatRenderer.cpp
@@ -14,7 +14,7 @@ void BoatRenderer::render(std::shared_ptr<Entity> _boat, double x, double y, dou
 {
 	// 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
- 	std::shared_ptr<Boat> boat = dynamic_pointer_cast<Boat>(_boat);
+ 	std::shared_ptr<Boat> boat = std::dynamic_pointer_cast<Boat>(_boat);
 
     glPushMatrix();
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/ChestRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/ChestRenderer.cpp
index ad4117296..ed0a215c4 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/ChestRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/ChestRenderer.cpp
@@ -21,7 +21,7 @@ ChestRenderer::~ChestRenderer()
 void ChestRenderer::render(std::shared_ptr<TileEntity>  _chest, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
 {
 	// 4J Convert as we aren't using a templated class
-	std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(_chest);
+	std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(_chest);
 
 	int data;
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/ChickenRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/ChickenRenderer.cpp
index 14d5169f3..ca795fee8 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/ChickenRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/ChickenRenderer.cpp
@@ -15,7 +15,7 @@ void ChickenRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, d
 float ChickenRenderer::getBob(std::shared_ptr<Mob> _mob, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Chicken> mob = dynamic_pointer_cast<Chicken>(_mob);
+	std::shared_ptr<Chicken> mob = std::dynamic_pointer_cast<Chicken>(_mob);
 
     float flap = mob->oFlap+(mob->flap-mob->oFlap)*a;
     float flapSpeed = mob->oFlapSpeed+(mob->flapSpeed-mob->oFlapSpeed)*a;
diff --git a/Minecraft.Client/Rendering/EntityRenderers/CreeperRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/CreeperRenderer.cpp
index e4c89d55b..db02d7bcd 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/CreeperRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/CreeperRenderer.cpp
@@ -11,7 +11,7 @@ CreeperRenderer::CreeperRenderer() : MobRenderer( new CreeperModel(), 0.5f )
 
 void CreeperRenderer::scale(std::shared_ptr<Mob> mob, float a)
 {
-    std::shared_ptr<Creeper> creeper = dynamic_pointer_cast<Creeper>(mob);
+    std::shared_ptr<Creeper> creeper = std::dynamic_pointer_cast<Creeper>(mob);
 
     float g = creeper->getSwelling(a);
 
@@ -27,7 +27,7 @@ void CreeperRenderer::scale(std::shared_ptr<Mob> mob, float a)
 
 int CreeperRenderer::getOverlayColor(std::shared_ptr<Mob> mob, float br, float a)
 {
-	std::shared_ptr<Creeper> creeper = dynamic_pointer_cast<Creeper>(mob);
+	std::shared_ptr<Creeper> creeper = std::dynamic_pointer_cast<Creeper>(mob);
 
     float step = creeper->getSwelling(a);
 
@@ -47,7 +47,7 @@ int CreeperRenderer::getOverlayColor(std::shared_ptr<Mob> mob, float br, float a
 int CreeperRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Creeper> mob = dynamic_pointer_cast<Creeper>(_mob);
+	std::shared_ptr<Creeper> mob = std::dynamic_pointer_cast<Creeper>(_mob);
     if (mob->isPowered())
 	{
 		if (mob->isInvisible())	glDepthMask(false);
diff --git a/Minecraft.Client/Rendering/EntityRenderers/EnchantTableRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/EnchantTableRenderer.cpp
index 43cf4bffd..92d1d4233 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/EnchantTableRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/EnchantTableRenderer.cpp
@@ -17,7 +17,7 @@ EnchantTableRenderer::~EnchantTableRenderer()
 void EnchantTableRenderer::render(std::shared_ptr<TileEntity> _table, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
 {
 	// 4J Convert as we aren't using a templated class
-	std::shared_ptr<EnchantmentTableEntity> table = dynamic_pointer_cast<EnchantmentTableEntity>(_table);
+	std::shared_ptr<EnchantmentTableEntity> table = std::dynamic_pointer_cast<EnchantmentTableEntity>(_table);
 
 #ifdef __PSVITA__
 	// AP - the book pages are made with 0 depth so the front and back polys are at the same location. This can cause z-fighting if culling is disabled which can sometimes happen
diff --git a/Minecraft.Client/Rendering/EntityRenderers/EnderChestRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/EnderChestRenderer.cpp
index d814fba9c..7fce13c64 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/EnderChestRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/EnderChestRenderer.cpp
@@ -6,7 +6,7 @@
 void EnderChestRenderer::render(std::shared_ptr<TileEntity>  _chest, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
 {
 	// 4J Convert as we aren't using a templated class
-	std::shared_ptr<EnderChestTileEntity> chest = dynamic_pointer_cast<EnderChestTileEntity>(_chest);
+	std::shared_ptr<EnderChestTileEntity> chest = std::dynamic_pointer_cast<EnderChestTileEntity>(_chest);
 
 	int data = 0;
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/EnderCrystalRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/EnderCrystalRenderer.cpp
index 41487b15c..3cbdc7aae 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/EnderCrystalRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/EnderCrystalRenderer.cpp
@@ -13,7 +13,7 @@ void EnderCrystalRenderer::render(std::shared_ptr<Entity> _crystal, double x, do
 {
 	// 4J - original version used generics and thus had an input parameter of type EnderCrystal rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<EnderCrystal> crystal = dynamic_pointer_cast<EnderCrystal>(_crystal);
+	std::shared_ptr<EnderCrystal> crystal = std::dynamic_pointer_cast<EnderCrystal>(_crystal);
 	if (currentModel != EnderCrystalModel::MODEL_ID)
 	{
 		model = new EnderCrystalModel(0);
diff --git a/Minecraft.Client/Rendering/EntityRenderers/EnderDragonRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/EnderDragonRenderer.cpp
index e80c9509c..a9f067e7f 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/EnderDragonRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/EnderDragonRenderer.cpp
@@ -18,7 +18,7 @@ EnderDragonRenderer::EnderDragonRenderer() : MobRenderer(new DragonModel(0), 0.5
 void EnderDragonRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a)
 {		
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
+	std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob);
 
 	// 4J - reorganised a bit so we can free allocations
 	double lpComponents[3];
@@ -49,7 +49,7 @@ void EnderDragonRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, f
 void EnderDragonRenderer::renderModel(std::shared_ptr<Entity> _mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
+	std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob);
 
 	if (mob->dragonDeathTime > 0)
 	{
@@ -90,7 +90,7 @@ void EnderDragonRenderer::renderModel(std::shared_ptr<Entity> _mob, float wp, fl
 void EnderDragonRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
+	std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob);
 	EnderDragonRenderer::bossInstance = mob;
 	if (currentModel != DragonModel::MODEL_ID)
 	{
@@ -170,7 +170,7 @@ void EnderDragonRenderer::render(std::shared_ptr<Entity> _mob, double x, double
 void EnderDragonRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
 {		
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
+	std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob);
 	MobRenderer::additionalRendering(mob, a);
 	Tesselator *t = Tesselator::getInstance();
 
@@ -230,7 +230,7 @@ void EnderDragonRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a
 int EnderDragonRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
+	std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob);
 
 	if (layer == 1)
 	{
diff --git a/Minecraft.Client/Rendering/EntityRenderers/EnderManRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/EnderManRenderer.cpp
index e5e4481fc..0f5704f77 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/EnderManRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/EnderManRenderer.cpp
@@ -14,7 +14,7 @@ void EndermanRenderer::render(std::shared_ptr<Entity> _mob, double x, double y,
 {
 	// 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
+	std::shared_ptr<EnderMan> mob = std::dynamic_pointer_cast<EnderMan>(_mob);
 
 	model->carrying = mob->getCarryingTile() > 0;
 	model->creepy = mob->isCreepy();
@@ -33,7 +33,7 @@ void EndermanRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
 {
 	// 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
+	std::shared_ptr<EnderMan> mob = std::dynamic_pointer_cast<EnderMan>(_mob);
 
 	MobRenderer::additionalRendering(_mob, a);
 
@@ -72,7 +72,7 @@ int EndermanRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a
 {
 	// 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
+	std::shared_ptr<EnderMan> mob = std::dynamic_pointer_cast<EnderMan>(_mob);
 
 	if (layer != 0) return -1;
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/EntityRenderDispatcher.cpp b/Minecraft.Client/Rendering/EntityRenderers/EntityRenderDispatcher.cpp
index 545cb47b7..bfb07c214 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/EntityRenderDispatcher.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/EntityRenderDispatcher.cpp
@@ -197,7 +197,7 @@ void EntityRenderDispatcher::prepare(Level *level, Textures *textures, Font *fon
         playerRotX = player->xRotO + (player->xRot - player->xRotO) * a;
     }
 
-	std::shared_ptr<Player> pl = dynamic_pointer_cast<Player>(player);
+	std::shared_ptr<Player> pl = std::dynamic_pointer_cast<Player>(player);
 	if (pl->ThirdPersonView() == 2)
 	{
 		playerRotY += 180;
diff --git a/Minecraft.Client/Rendering/EntityRenderers/EntityRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/EntityRenderer.cpp
index ed9678837..7960e7d4d 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/EntityRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/EntityRenderer.cpp
@@ -160,17 +160,17 @@ void EntityRenderer::renderShadow(std::shared_ptr<Entity> e, double x, double y,
 
     glDepthMask(false);
     float r = shadowRadius;
-	std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e);
+	std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(e);
 	bool isLocalPlayer = false;
 	float fYLocalPlayerShadowOffset=0.0f;
 
-	//if (dynamic_pointer_cast<Mob>(e) != NULL)
+	//if (std::dynamic_pointer_cast<Mob>(e) != NULL)
 	if (mob != NULL)
 	{
-		//std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e);
+		//std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(e);
 		r *= mob->getSizeScale();
 
-		std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(mob);
+		std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(mob);
 		if (animal != NULL)
 		{
 			if (animal->isBaby())
@@ -179,7 +179,7 @@ void EntityRenderer::renderShadow(std::shared_ptr<Entity> e, double x, double y,
 			}
 		}
 
-		if(dynamic_pointer_cast<LocalPlayer>(mob)!=NULL)
+		if(std::dynamic_pointer_cast<LocalPlayer>(mob)!=NULL)
 		{
 			isLocalPlayer=true;
 		}
diff --git a/Minecraft.Client/Rendering/EntityRenderers/ExperienceOrbRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/ExperienceOrbRenderer.cpp
index 0d03fa1d6..f555bb1f4 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/ExperienceOrbRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/ExperienceOrbRenderer.cpp
@@ -21,7 +21,7 @@ ExperienceOrbRenderer::ExperienceOrbRenderer()
 
 void ExperienceOrbRenderer::render(std::shared_ptr<Entity> _orb, double x, double y, double z, float rot, float a)
 {
-	std::shared_ptr<ExperienceOrb> orb = dynamic_pointer_cast<ExperienceOrb>(_orb);
+	std::shared_ptr<ExperienceOrb> orb = std::dynamic_pointer_cast<ExperienceOrb>(_orb);
 	glPushMatrix();
 	glTranslatef((float) x, (float) y, (float) z);
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/FallingTileRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/FallingTileRenderer.cpp
index a7dc677d3..e41010e61 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/FallingTileRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/FallingTileRenderer.cpp
@@ -15,7 +15,7 @@ FallingTileRenderer::FallingTileRenderer() : EntityRenderer()
 void FallingTileRenderer::render(std::shared_ptr<Entity> _tile, double x, double y, double z, float rot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<FallingTile> tile = dynamic_pointer_cast<FallingTile>(_tile);
+	std::shared_ptr<FallingTile> tile = std::dynamic_pointer_cast<FallingTile>(_tile);
 	glPushMatrix();
 	glTranslatef((float) x, (float) y, (float) z);
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/FireballRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/FireballRenderer.cpp
index 428ff3dff..399faee27 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/FireballRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/FireballRenderer.cpp
@@ -15,7 +15,7 @@ FireballRenderer::FireballRenderer(float scale)
 void FireballRenderer::render(std::shared_ptr<Entity> _fireball, double x, double y, double z, float rot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Fireball> fireball = dynamic_pointer_cast<Fireball>(_fireball);
+	std::shared_ptr<Fireball> fireball = std::dynamic_pointer_cast<Fireball>(_fireball);
 
     glPushMatrix();
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/FishingHookRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/FishingHookRenderer.cpp
index fe3912ab0..95af3d46d 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/FishingHookRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/FishingHookRenderer.cpp
@@ -11,7 +11,7 @@
 void FishingHookRenderer::render(std::shared_ptr<Entity> _hook, double x, double y, double z, float rot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<FishingHook> hook = dynamic_pointer_cast<FishingHook>(_hook);
+	std::shared_ptr<FishingHook> hook = std::dynamic_pointer_cast<FishingHook>(_hook);
 
     glPushMatrix();
 
@@ -62,7 +62,7 @@ void FishingHookRenderer::render(std::shared_ptr<Entity> _hook, double x, double
         double xp = hook->owner->xo + (hook->owner->x - hook->owner->xo) * a + vv->x;
         double yp = hook->owner->yo + (hook->owner->y - hook->owner->yo) * a + vv->y;
         double zp = hook->owner->zo + (hook->owner->z - hook->owner->zo) * a + vv->z;
-		double yOffset = hook->owner != dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player) ? hook->owner->getHeadHeight() : 0;
+		double yOffset = hook->owner != std::dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player) ? hook->owner->getHeadHeight() : 0;
 
 		// 4J-PB - changing this to be per player
 		//if (this->entityRenderDispatcher->options->thirdPersonView)
diff --git a/Minecraft.Client/Rendering/EntityRenderers/GhastRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/GhastRenderer.cpp
index 85648e745..fe373d06d 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/GhastRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/GhastRenderer.cpp
@@ -9,7 +9,7 @@ GhastRenderer::GhastRenderer() : MobRenderer(new GhastModel(), 0.5f)
 
 void GhastRenderer::scale(std::shared_ptr<Mob> mob, float a)
 {
-	std::shared_ptr<Ghast> ghast = dynamic_pointer_cast<Ghast>(mob);
+	std::shared_ptr<Ghast> ghast = std::dynamic_pointer_cast<Ghast>(mob);
         
 	float ss = (ghast->oCharge+(ghast->charge-ghast->oCharge)*a)/20.0f;
 	if (ss<0) ss = 0;
diff --git a/Minecraft.Client/Rendering/EntityRenderers/ItemFrameRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/ItemFrameRenderer.cpp
index cc54ac039..fdb3d5554 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/ItemFrameRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/ItemFrameRenderer.cpp
@@ -27,7 +27,7 @@ void ItemFrameRenderer::render(std::shared_ptr<Entity>  _itemframe, double x, do
 {
 	// 4J - original version used generics and thus had an input parameter of type EnderCrystal rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<ItemFrame> itemFrame = dynamic_pointer_cast<ItemFrame>(_itemframe);
+	std::shared_ptr<ItemFrame> itemFrame = std::dynamic_pointer_cast<ItemFrame>(_itemframe);
 
 	glPushMatrix();
 	float xOffs = (float) (itemFrame->x - x) - 0.5f;
diff --git a/Minecraft.Client/Rendering/EntityRenderers/ItemInHandRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/ItemInHandRenderer.cpp
index e243925a0..6ed000bb0 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/ItemInHandRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/ItemInHandRenderer.cpp
@@ -319,7 +319,7 @@ void ItemInHandRenderer::render(float a)
 	float fudgeY = 0.0f;
 	float fudgeZ = 0.0f;
 	bool splitHoriz = false;
-	std::shared_ptr<LocalPlayer> localPlayer = dynamic_pointer_cast<LocalPlayer>(player);
+	std::shared_ptr<LocalPlayer> localPlayer = std::dynamic_pointer_cast<LocalPlayer>(player);
 	if( localPlayer )
 	{
 		if( localPlayer->m_iScreenSection == C4JRender::VIEWPORT_TYPE_SPLIT_BOTTOM ||
diff --git a/Minecraft.Client/Rendering/EntityRenderers/ItemRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/ItemRenderer.cpp
index 82c2b3713..184484e74 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/ItemRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/ItemRenderer.cpp
@@ -32,7 +32,7 @@ ItemRenderer::~ItemRenderer()
 void ItemRenderer::render(std::shared_ptr<Entity> _itemEntity, double x, double y, double z, float rot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<ItemEntity> itemEntity = dynamic_pointer_cast<ItemEntity>(_itemEntity);
+	std::shared_ptr<ItemEntity> itemEntity = std::dynamic_pointer_cast<ItemEntity>(_itemEntity);
 
     random->setSeed(187);
     std::shared_ptr<ItemInstance> item = itemEntity->getItem();
diff --git a/Minecraft.Client/Rendering/EntityRenderers/ItemSpriteRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/ItemSpriteRenderer.cpp
index f9d68a60e..bd8b79ca9 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/ItemSpriteRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/ItemSpriteRenderer.cpp
@@ -37,7 +37,7 @@ void ItemSpriteRenderer::render(std::shared_ptr<Entity> e, double x, double y, d
 	if (icon == PotionItem::getTexture(PotionItem::THROWABLE_ICON) )
 	{
 
-		int col = PotionBrewing::getColorValue((dynamic_pointer_cast<ThrownPotion>(e) )->getPotionValue(), false);
+		int col = PotionBrewing::getColorValue((std::dynamic_pointer_cast<ThrownPotion>(e) )->getPotionValue(), false);
 		float red = ((col >> 16) & 0xff) / 255.0f;
 		float g = ((col >> 8) & 0xff) / 255.0f;
 		float b = ((col) & 0xff) / 255.0f;
diff --git a/Minecraft.Client/Rendering/EntityRenderers/LavaSlimeRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/LavaSlimeRenderer.cpp
index c6113cf15..09ea2c83f 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/LavaSlimeRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/LavaSlimeRenderer.cpp
@@ -12,7 +12,7 @@ void LavaSlimeRenderer::render(std::shared_ptr<Entity> _mob, double x, double y,
 {		
 	// 4J - original version used generics and thus had an input parameter of type LavaSlime rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<LavaSlime> mob = dynamic_pointer_cast<LavaSlime>(_mob);
+	std::shared_ptr<LavaSlime> mob = std::dynamic_pointer_cast<LavaSlime>(_mob);
 	int modelVersion = ((LavaSlimeModel *) model)->getModelVersion();
 	if (modelVersion != this->modelVersion)
 	{
@@ -27,7 +27,7 @@ void LavaSlimeRenderer::scale(std::shared_ptr<Mob> _slime, float a)
 {
 	// 4J - original version used generics and thus had an input parameter of type LavaSlime rather than std::shared_ptr<Mob>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<LavaSlime> slime = dynamic_pointer_cast<LavaSlime>(_slime);
+	std::shared_ptr<LavaSlime> slime = std::dynamic_pointer_cast<LavaSlime>(_slime);
 	int size = slime->getSize();
 	float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1);
 	float w = 1 / (ss + 1);
diff --git a/Minecraft.Client/Rendering/EntityRenderers/LightningBoltRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/LightningBoltRenderer.cpp
index 7648586fa..d4d5b8d5d 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/LightningBoltRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/LightningBoltRenderer.cpp
@@ -6,7 +6,7 @@
 void LightningBoltRenderer::render(std::shared_ptr<Entity> _bolt, double x, double y, double z, float rot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<LightningBolt> bolt = dynamic_pointer_cast<LightningBolt>(_bolt);
+	std::shared_ptr<LightningBolt> bolt = std::dynamic_pointer_cast<LightningBolt>(_bolt);
 
     Tesselator *t = Tesselator::getInstance();
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/MinecartRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/MinecartRenderer.cpp
index be16ddaa3..0b0d7077b 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/MinecartRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/MinecartRenderer.cpp
@@ -13,7 +13,7 @@ MinecartRenderer::MinecartRenderer()
 void MinecartRenderer::render(std::shared_ptr<Entity> _cart, double x, double y, double z, float rot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Minecart> cart = dynamic_pointer_cast<Minecart>(_cart);
+	std::shared_ptr<Minecart> cart = std::dynamic_pointer_cast<Minecart>(_cart);
 
     glPushMatrix();
 	
diff --git a/Minecraft.Client/Rendering/EntityRenderers/MobRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/MobRenderer.cpp
index dae750050..5c4ca6a38 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/MobRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/MobRenderer.cpp
@@ -35,7 +35,7 @@ void MobRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, doubl
 {
 	// 4J - added - this used to use generics so the input parameter could be a mob (or derived type), but we aren't
 	// able to do that so dynamically casting to get the more specific type here.
-	std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(_mob);
+	std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(_mob);
     glPushMatrix();
     glDisable(GL_CULL_FACE);
 
@@ -52,9 +52,9 @@ void MobRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, doubl
         float bodyRot = rotlerp(mob->yBodyRotO, mob->yBodyRot, a);
         float headRot = rotlerp(mob->yHeadRotO, mob->yHeadRot, a);
 
-		if (mob->isRiding() && dynamic_pointer_cast<Mob>(mob->riding))
+		if (mob->isRiding() && std::dynamic_pointer_cast<Mob>(mob->riding))
 		{
-			std::shared_ptr<Mob> riding = dynamic_pointer_cast<Mob>(mob->riding);
+			std::shared_ptr<Mob> riding = std::dynamic_pointer_cast<Mob>(mob->riding);
 			bodyRot = rotlerp(riding->yBodyRotO, riding->yBodyRot, a);
 
 			float headDiff = Mth::wrapDegrees(headRot - bodyRot);
@@ -235,7 +235,7 @@ void MobRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, doubl
 
 void MobRenderer::renderModel(std::shared_ptr<Entity> mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale)
 {
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player);
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player);
 
 	bindTexture(mob->customTextureUrl, mob->getTexture());
 	if (!mob->isInvisible())
@@ -396,7 +396,7 @@ void MobRenderer::renderNameTag(std::shared_ptr<Mob> mob, const std::wstring& Or
 	Tesselator *t = Tesselator::getInstance();
 
 	int offs = 0;
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob);
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mob);
 	if (player != NULL && app.isXuidDeadmau5( player->getXuid() ) ) offs = -10;
 
 	std::wstring playerName;
diff --git a/Minecraft.Client/Rendering/EntityRenderers/MobSpawnerRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/MobSpawnerRenderer.cpp
index 072a54bcc..6c4f6a928 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/MobSpawnerRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/MobSpawnerRenderer.cpp
@@ -8,7 +8,7 @@
 void MobSpawnerRenderer::render(std::shared_ptr<TileEntity> _spawner, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<MobSpawnerTileEntity> spawner = dynamic_pointer_cast<MobSpawnerTileEntity>(_spawner);
+	std::shared_ptr<MobSpawnerTileEntity> spawner = std::dynamic_pointer_cast<MobSpawnerTileEntity>(_spawner);
 
 	glPushMatrix();
     glTranslatef((float) x + 0.5f, (float) y, (float) z + 0.5f);
diff --git a/Minecraft.Client/Rendering/EntityRenderers/MushroomCowRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/MushroomCowRenderer.cpp
index 0ab520d8f..d59fa9036 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/MushroomCowRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/MushroomCowRenderer.cpp
@@ -13,7 +13,7 @@ void MushroomCowRenderer::render(std::shared_ptr<Entity> _mob, double x, double
 {
 	// 4J - original version used generics and thus had an input parameter of type MushroomCow rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	//std::shared_ptr<MushroomCow> mob = dynamic_pointer_cast<MushroomCow>(_mob);
+	//std::shared_ptr<MushroomCow> mob = std::dynamic_pointer_cast<MushroomCow>(_mob);
 
 	// 4J Stu - No need to do the cast, just pass through as-is
 	MobRenderer::render(_mob, x, y, z, rot, a);
@@ -23,7 +23,7 @@ void MushroomCowRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a
 {
 	// 4J - original version used generics and thus had an input parameter of type MushroomCow rather than std::shared_ptr<Mob>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<MushroomCow> mob = dynamic_pointer_cast<MushroomCow>(_mob);
+	std::shared_ptr<MushroomCow> mob = std::dynamic_pointer_cast<MushroomCow>(_mob);
 	MobRenderer::additionalRendering(mob, a);
 	if (mob->isBaby()) return;
 	bindTexture(TN_TERRAIN); // 4J was "/terrain.png"
diff --git a/Minecraft.Client/Rendering/EntityRenderers/OcelotRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/OcelotRenderer.cpp
index b1cf46be3..2abb15113 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/OcelotRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/OcelotRenderer.cpp
@@ -15,7 +15,7 @@ void OzelotRenderer::scale(std::shared_ptr<Mob> _mob, float a)
 {
 	// 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<Ozelot> mob = dynamic_pointer_cast<Ozelot>(_mob);
+	std::shared_ptr<Ozelot> mob = std::dynamic_pointer_cast<Ozelot>(_mob);
 	MobRenderer::scale(mob, a);
 	if (mob->isTame())
 	{
diff --git a/Minecraft.Client/Rendering/EntityRenderers/PaintingRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/PaintingRenderer.cpp
index e61ecda78..356b76492 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/PaintingRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/PaintingRenderer.cpp
@@ -14,7 +14,7 @@ PaintingRenderer::PaintingRenderer()
 void PaintingRenderer::render(std::shared_ptr<Entity> _painting, double x, double y, double z, float rot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Painting> painting = dynamic_pointer_cast<Painting>(_painting);
+	std::shared_ptr<Painting> painting = std::dynamic_pointer_cast<Painting>(_painting);
 	
     random->setSeed(187);
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/PigRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/PigRenderer.cpp
index 88c46faf4..eb7af5da4 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/PigRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/PigRenderer.cpp
@@ -10,7 +10,7 @@ PigRenderer::PigRenderer(Model *model, Model *armor, float shadow) : MobRenderer
 int PigRenderer::prepareArmor(std::shared_ptr<Mob> _pig, int layer, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(_pig);
+	std::shared_ptr<Pig> pig = std::dynamic_pointer_cast<Pig>(_pig);
 
 	MemSect(31);
     bindTexture(TN_MOB_SADDLE);	// 4J was L"/mob/saddle.png"
diff --git a/Minecraft.Client/Rendering/EntityRenderers/PistonPieceRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/PistonPieceRenderer.cpp
index f5720e05b..37cd733aa 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/PistonPieceRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/PistonPieceRenderer.cpp
@@ -15,7 +15,7 @@ PistonPieceRenderer::PistonPieceRenderer()
 void PistonPieceRenderer::render(std::shared_ptr<TileEntity> _entity, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<PistonPieceEntity> entity = dynamic_pointer_cast<PistonPieceEntity>(_entity);
+	std::shared_ptr<PistonPieceEntity> entity = std::dynamic_pointer_cast<PistonPieceEntity>(_entity);
 
     Tile *tile = Tile::tiles[entity->getId()];
     if (tile != NULL && entity->getProgress(a) <= 1)	// 4J - changed condition from < to <= as our chunk update is async to main thread and so we can have to render these with progress of 1
diff --git a/Minecraft.Client/Rendering/EntityRenderers/PlayerRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/PlayerRenderer.cpp
index eaec4c2d2..156b6102b 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/PlayerRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/PlayerRenderer.cpp
@@ -49,7 +49,7 @@ unsigned int PlayerRenderer::getNametagColour(int index)
 int PlayerRenderer::prepareArmor(std::shared_ptr<Mob> _player, int layer, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(_player);
 
 	// 4J-PB - need to disable rendering armour for some special skins (Daleks)
 	unsigned int uiAnimOverrideBitmask=player->getAnimOverrideBitmask();
@@ -111,7 +111,7 @@ int PlayerRenderer::prepareArmor(std::shared_ptr<Mob> _player, int layer, float
 void PlayerRenderer::prepareSecondPassArmor(std::shared_ptr<Mob> _player, int layer, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(_player);
 	std::shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
 	if (itemInstance != NULL)
 	{
@@ -130,7 +130,7 @@ void PlayerRenderer::prepareSecondPassArmor(std::shared_ptr<Mob> _player, int la
 void PlayerRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
+	std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob);
 
 	if(mob->hasInvisiblePrivilege()) return;
 
@@ -169,7 +169,7 @@ void PlayerRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, do
     armorParts1->sneaking = armorParts2->sneaking = humanoidModel->sneaking = mob->isSneaking();
 
     double yp = y - mob->heightOffset;
-    if (mob->isSneaking() && (dynamic_pointer_cast<LocalPlayer>(mob) == NULL))
+    if (mob->isSneaking() && (std::dynamic_pointer_cast<LocalPlayer>(mob) == NULL))
 	{
         yp -= 2 / 16.0f;
     }
@@ -231,7 +231,7 @@ void PlayerRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, do
 void PlayerRenderer::renderName(std::shared_ptr<Mob> _mob, double x, double y, double z)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
+	std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob);
 
     if (Minecraft::renderNames() && mob != entityRenderDispatcher->cameraEntity
 		&& !mob->isInvisibleTo(Minecraft::GetInstance()->player) ) // 4J-JEV: Todo, move to LivingEntityRenderer.
@@ -321,7 +321,7 @@ void PlayerRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
 	MobRenderer::additionalRendering(_mob,a);
 
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
+	std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob);
 
     std::shared_ptr<ItemInstance> headGear = mob->inventory->getArmor(3);
     if (headGear != NULL)
@@ -543,7 +543,7 @@ void PlayerRenderer::renderHand()
 void PlayerRenderer::setupPosition(std::shared_ptr<Mob> _mob, double x, double y, double z)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
+	std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob);
 
     if (mob->isAlive() && mob->isSleeping())
 	{
@@ -559,7 +559,7 @@ void PlayerRenderer::setupPosition(std::shared_ptr<Mob> _mob, double x, double y
 void PlayerRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
+	std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob);
 
     if (mob->isAlive() && mob->isSleeping())
 	{
@@ -578,7 +578,7 @@ void PlayerRenderer::renderShadow(std::shared_ptr<Entity> e, double x, double y,
 {
 	if(app.GetGameHostOption(eGameHostOption_HostCanBeInvisible) > 0)
 	{
-		std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
+		std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
 		if(player != NULL && player->hasInvisiblePrivilege()) return;
 	}
 	EntityRenderer::renderShadow(e,x,y,z,pow,a);
diff --git a/Minecraft.Client/Rendering/EntityRenderers/SheepRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/SheepRenderer.cpp
index 337bbfcc4..f30a79198 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/SheepRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/SheepRenderer.cpp
@@ -11,7 +11,7 @@ SheepRenderer::SheepRenderer(Model *model, Model *armor, float shadow) : MobRend
 int SheepRenderer::prepareArmor(std::shared_ptr<Mob> _sheep, int layer, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(_sheep);
+	std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(_sheep);
 
     if (layer == 0 && !sheep->isSheared() &&
 		!sheep->isInvisibleTo(Minecraft::GetInstance()->player)) // 4J-JEV: Todo, merge with java fix (for invisible sheep armour) in '1.7.5'.
diff --git a/Minecraft.Client/Rendering/EntityRenderers/SignRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/SignRenderer.cpp
index 43e8a7e14..0b7147724 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/SignRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/SignRenderer.cpp
@@ -16,7 +16,7 @@ SignRenderer::SignRenderer()
 void SignRenderer::render(std::shared_ptr<TileEntity> _sign, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<SignTileEntity> sign = dynamic_pointer_cast<SignTileEntity>(_sign);
+	std::shared_ptr<SignTileEntity> sign = std::dynamic_pointer_cast<SignTileEntity>(_sign);
 
     Tile *tile = sign->getTile();
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/SkullTileRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/SkullTileRenderer.cpp
index 71f1f137f..b3f19b02d 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/SkullTileRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/SkullTileRenderer.cpp
@@ -21,7 +21,7 @@ SkullTileRenderer::~SkullTileRenderer()
 
 void SkullTileRenderer::render(std::shared_ptr<TileEntity> _skull, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
 {
-	std::shared_ptr<SkullTileEntity> skull = dynamic_pointer_cast<SkullTileEntity>(_skull);
+	std::shared_ptr<SkullTileEntity> skull = std::dynamic_pointer_cast<SkullTileEntity>(_skull);
 	renderSkull((float) x, (float) y, (float) z, skull->getData() & SkullTile::PLACEMENT_MASK, skull->getRotation() * 360 / 16.0f, skull->getSkullType(), skull->getExtraType());
 }
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/SlimeRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/SlimeRenderer.cpp
index f4d84c61c..94fdf85ff 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/SlimeRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/SlimeRenderer.cpp
@@ -10,7 +10,7 @@ SlimeRenderer::SlimeRenderer(Model *model, Model *armor, float shadow) : MobRend
 int SlimeRenderer::prepareArmor(std::shared_ptr<Mob> _slime, int layer, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(_slime);
+	std::shared_ptr<Slime> slime = std::dynamic_pointer_cast<Slime>(_slime);
 
 	if (slime->isInvisible()) return 0;
 
@@ -35,7 +35,7 @@ int SlimeRenderer::prepareArmor(std::shared_ptr<Mob> _slime, int layer, float a)
 void SlimeRenderer::scale(std::shared_ptr<Mob> _slime, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(_slime);
+	std::shared_ptr<Slime> slime = std::dynamic_pointer_cast<Slime>(_slime);
 
     float size = (float) slime->getSize();
     float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1);
diff --git a/Minecraft.Client/Rendering/EntityRenderers/SnowManRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/SnowManRenderer.cpp
index e08b61570..8324b771d 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/SnowManRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/SnowManRenderer.cpp
@@ -17,7 +17,7 @@ void SnowManRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
 {
 	// 4J - original version used generics and thus had an input parameter of type SnowMan rather than std::shared_ptr<Mob>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<SnowMan> mob = dynamic_pointer_cast<SnowMan>(_mob);
+	std::shared_ptr<SnowMan> mob = std::dynamic_pointer_cast<SnowMan>(_mob);
 
 	MobRenderer::additionalRendering(mob, a);
 	std::shared_ptr<ItemInstance> headGear = std::shared_ptr<ItemInstance>( new ItemInstance(Tile::pumpkin, 1) );
diff --git a/Minecraft.Client/Rendering/EntityRenderers/SpiderRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/SpiderRenderer.cpp
index d9d7e9fd7..2055bfa82 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/SpiderRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/SpiderRenderer.cpp
@@ -16,7 +16,7 @@ float SpiderRenderer::getFlipDegrees(std::shared_ptr<Mob> spider)
 int SpiderRenderer::prepareArmor(std::shared_ptr<Mob> _spider, int layer, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Spider> spider = dynamic_pointer_cast<Spider>(_spider);
+	std::shared_ptr<Spider> spider = std::dynamic_pointer_cast<Spider>(_spider);
 
     if (layer!=0) return -1;
 	MemSect(31);
@@ -55,7 +55,7 @@ int SpiderRenderer::prepareArmor(std::shared_ptr<Mob> _spider, int layer, float
 void SpiderRenderer::scale(std::shared_ptr<Mob> _mob, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Spider> mob = dynamic_pointer_cast<Spider>(_mob);
+	std::shared_ptr<Spider> mob = std::dynamic_pointer_cast<Spider>(_mob);
 	float scale = mob->getModelScale();
 	glScalef(scale, scale, scale);
 }
\ No newline at end of file
diff --git a/Minecraft.Client/Rendering/EntityRenderers/SquidRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/SquidRenderer.cpp
index 81ec4b5f8..e7322d3d4 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/SquidRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/SquidRenderer.cpp
@@ -14,7 +14,7 @@ void SquidRenderer::render(std::shared_ptr<Entity> mob, double x, double y, doub
 void SquidRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Squid> mob = dynamic_pointer_cast<Squid>(_mob);
+	std::shared_ptr<Squid> mob = std::dynamic_pointer_cast<Squid>(_mob);
 
     float bodyXRot = (mob->xBodyRotO + (mob->xBodyRot - mob->xBodyRotO) * a);
     float bodyZRot = (mob->zBodyRotO + (mob->zBodyRot - mob->zBodyRotO) * a);
@@ -29,7 +29,7 @@ void SquidRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float b
 float SquidRenderer::getBob(std::shared_ptr<Mob> _mob, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Squid> mob = dynamic_pointer_cast<Squid>(_mob);
+	std::shared_ptr<Squid> mob = std::dynamic_pointer_cast<Squid>(_mob);
 
     return mob->oldTentacleAngle + (mob->tentacleAngle - mob->oldTentacleAngle) * a;
 }
\ No newline at end of file
diff --git a/Minecraft.Client/Rendering/EntityRenderers/TheEndPortalRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/TheEndPortalRenderer.cpp
index 8877b9d77..beb2effb8 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/TheEndPortalRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/TheEndPortalRenderer.cpp
@@ -10,7 +10,7 @@
 void TheEndPortalRenderer::render(std::shared_ptr<TileEntity> _table, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
 {
 	// 4J Convert as we aren't using a templated class
-	std::shared_ptr<TheEndPortalTileEntity> table = dynamic_pointer_cast<TheEndPortalTileEntity>(_table);
+	std::shared_ptr<TheEndPortalTileEntity> table = std::dynamic_pointer_cast<TheEndPortalTileEntity>(_table);
 	float xx = (float) (tileEntityRenderDispatcher->xPlayer);
 	float yy = (float) (tileEntityRenderDispatcher->yPlayer);
 	float zz = (float) (tileEntityRenderDispatcher->zPlayer);
diff --git a/Minecraft.Client/Rendering/EntityRenderers/TntRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/TntRenderer.cpp
index 963d8af9f..3f1ae5c8e 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/TntRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/TntRenderer.cpp
@@ -13,7 +13,7 @@ TntRenderer::TntRenderer()
 void TntRenderer::render(std::shared_ptr<Entity> _tnt, double x, double y, double z, float rot, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<PrimedTnt> tnt = dynamic_pointer_cast<PrimedTnt>(_tnt);
+	std::shared_ptr<PrimedTnt> tnt = std::dynamic_pointer_cast<PrimedTnt>(_tnt);
 
 	glPushMatrix();
     glTranslatef((float) x, (float) y, (float) z);
diff --git a/Minecraft.Client/Rendering/EntityRenderers/VillagerGolemRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/VillagerGolemRenderer.cpp
index 23330c1e7..1f495b297 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/VillagerGolemRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/VillagerGolemRenderer.cpp
@@ -24,7 +24,7 @@ void VillagerGolemRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob,
 {
 	// 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<VillagerGolem> mob = dynamic_pointer_cast<VillagerGolem>(_mob);
+	std::shared_ptr<VillagerGolem> mob = std::dynamic_pointer_cast<VillagerGolem>(_mob);
 	MobRenderer::setupRotations(mob, bob, bodyRot, a);
 	if (mob->walkAnimSpeed < 0.01) return;
 
@@ -38,7 +38,7 @@ void VillagerGolemRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float
 {
 	// 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<VillagerGolem> mob = dynamic_pointer_cast<VillagerGolem>(_mob);
+	std::shared_ptr<VillagerGolem> mob = std::dynamic_pointer_cast<VillagerGolem>(_mob);
 	MobRenderer::additionalRendering(mob, a);
 	if (mob->getOfferFlowerTick() == 0) return;
 
diff --git a/Minecraft.Client/Rendering/EntityRenderers/VillagerRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/VillagerRenderer.cpp
index 6cace8f59..465d76e13 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/VillagerRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/VillagerRenderer.cpp
@@ -31,7 +31,7 @@ void VillagerRenderer::scale(std::shared_ptr<Mob> _mob, float a)
 {
 	// 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity>  we have here - 
 	// do some casting around instead
-	std::shared_ptr<Villager> mob = dynamic_pointer_cast<Villager>(_mob);
+	std::shared_ptr<Villager> mob = std::dynamic_pointer_cast<Villager>(_mob);
 	float s = 15 / 16.0f;
 	if (mob->getAge() < 0)
 	{
diff --git a/Minecraft.Client/Rendering/EntityRenderers/WolfRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/WolfRenderer.cpp
index 150c8698b..f886f2db4 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/WolfRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/WolfRenderer.cpp
@@ -11,7 +11,7 @@ WolfRenderer::WolfRenderer(Model *model, Model *armor, float shadow) : MobRender
 float WolfRenderer::getBob(std::shared_ptr<Mob> _mob, float a)
 {
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
-	std::shared_ptr<Wolf> mob = dynamic_pointer_cast<Wolf>(_mob);
+	std::shared_ptr<Wolf> mob = std::dynamic_pointer_cast<Wolf>(_mob);
 
 	return mob->getTailAngle();
 }
@@ -20,7 +20,7 @@ int WolfRenderer::prepareArmor(std::shared_ptr<Mob> mob, int layer, float a)
 {
 	if (mob->isInvisibleTo(Minecraft::GetInstance()->player)) return -1; // 4J-JEV: Todo, merge with java fix in '1.7.5'.
 
-	std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(mob);
+	std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(mob);
 	if (layer == 0 && wolf->isWet())
 	{
 		float brightness = wolf->getBrightness(a) * wolf->getWetShade(a);
diff --git a/Minecraft.Client/Rendering/EntityRenderers/ZombieRenderer.cpp b/Minecraft.Client/Rendering/EntityRenderers/ZombieRenderer.cpp
index 265b8acde..8e47f334a 100644
--- a/Minecraft.Client/Rendering/EntityRenderers/ZombieRenderer.cpp
+++ b/Minecraft.Client/Rendering/EntityRenderers/ZombieRenderer.cpp
@@ -36,21 +36,21 @@ void ZombieRenderer::createArmorParts()
 
 int ZombieRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a)
 {
-	std::shared_ptr<Zombie> mob = dynamic_pointer_cast<Zombie>(_mob);
+	std::shared_ptr<Zombie> mob = std::dynamic_pointer_cast<Zombie>(_mob);
 	swapArmor(mob);
 	return HumanoidMobRenderer::prepareArmor(_mob, layer, a);
 }
 
 void ZombieRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
 {
-	std::shared_ptr<Zombie> mob = dynamic_pointer_cast<Zombie>(_mob);
+	std::shared_ptr<Zombie> mob = std::dynamic_pointer_cast<Zombie>(_mob);
 	swapArmor(mob);
 	HumanoidMobRenderer::render(_mob, x, y, z, rot, a);
 }
 
 void ZombieRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
 {
-	std::shared_ptr<Zombie> mob = dynamic_pointer_cast<Zombie>(_mob);
+	std::shared_ptr<Zombie> mob = std::dynamic_pointer_cast<Zombie>(_mob);
 	swapArmor(mob);
 	HumanoidMobRenderer::additionalRendering(_mob, a);
 }
@@ -82,7 +82,7 @@ void ZombieRenderer::swapArmor(std::shared_ptr<Zombie> mob)
 
 void ZombieRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a)
 {
-	std::shared_ptr<Zombie> mob = dynamic_pointer_cast<Zombie>(_mob);
+	std::shared_ptr<Zombie> mob = std::dynamic_pointer_cast<Zombie>(_mob);
 	if (mob->isConverting())
 	{
 		bodyRot += (float) (cos(mob->tickCount * 3.25) * PI * .25f);
diff --git a/Minecraft.Client/Rendering/GameRenderer.cpp b/Minecraft.Client/Rendering/GameRenderer.cpp
index 78f3f81c9..e87499204 100644
--- a/Minecraft.Client/Rendering/GameRenderer.cpp
+++ b/Minecraft.Client/Rendering/GameRenderer.cpp
@@ -276,7 +276,7 @@ void GameRenderer::tick(bool first)		// 4J - add bFirst
 
 	if (mc->cameraTargetPlayer == NULL)
 	{
-		mc->cameraTargetPlayer = dynamic_pointer_cast<Mob>(mc->player);
+		mc->cameraTargetPlayer = std::dynamic_pointer_cast<Mob>(mc->player);
 	}
 
 	float brr = mc->level->getBrightness(Mth::floor(mc->cameraTargetPlayer->x), Mth::floor(mc->cameraTargetPlayer->y), Mth::floor(mc->cameraTargetPlayer->z));
@@ -407,7 +407,7 @@ float GameRenderer::GetFovVal()
 
 void GameRenderer::tickFov()
 {
-	std::shared_ptr<LocalPlayer>player = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
+	std::shared_ptr<LocalPlayer>player = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
 
 	int playerIdx = player ? player->GetXboxPad() : 0;
     tFov[playerIdx] = player->getFieldOfViewModifier();
@@ -420,7 +420,7 @@ float GameRenderer::getFov(float a, bool applyEffects)
 {
 	if (cameraFlip > 0 ) return 90;
 
-	std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
+	std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
 	int playerIdx = player ? player->GetXboxPad() : 0;
 	float fov = m_fov;//70;
     if (applyEffects)
@@ -470,12 +470,12 @@ void GameRenderer::bobHurt(float a)
 
 void GameRenderer::bobView(float a)
 {
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mc->cameraTargetPlayer);
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mc->cameraTargetPlayer);
 	if(player==NULL)
 	{
 		return;
 	}
-	//std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mc->cameraTargetPlayer);
+	//std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mc->cameraTargetPlayer);
 
 	float wda = player->walkDist - player->walkDistO;
 	float b = -(player->walkDist + wda * a);
@@ -490,7 +490,7 @@ void GameRenderer::bobView(float a)
 void GameRenderer::moveCameraToPlayer(float a)
 {
 	std::shared_ptr<Mob> player = mc->cameraTargetPlayer;
-	std::shared_ptr<LocalPlayer> localplayer = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
+	std::shared_ptr<LocalPlayer> localplayer = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
 	float heightOffset = player->heightOffset - 1.62f;
 
 	double x = player->xo + (player->x - player->xo) * a;
@@ -724,7 +724,7 @@ void GameRenderer::renderItemInHand(float a, int eye)
 {
 	if (cameraFlip > 0) return;
 
-	std::shared_ptr<LocalPlayer> localplayer = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
+	std::shared_ptr<LocalPlayer> localplayer = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
 
 	// 4J-PB - to turn off the hand for screenshots, but not when the item held is a map
 	if ( localplayer!=NULL)
@@ -1405,10 +1405,10 @@ void GameRenderer::renderLevel(float a, __int64 until)
 			PIXEndNamedEvent();
 			turnOffLightLayer(a);		// 4J - brought forward from 1.8.2
 
-			std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(cameraEntity);
+			std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(cameraEntity);
 			if (mc->hitResult != NULL && cameraEntity->isUnderLiquid(Material::water) && player!=NULL) //&& !mc->options.hideGui)
 			{
-				//std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(cameraEntity);
+				//std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(cameraEntity);
 				glDisable(GL_ALPHA_TEST);
 				levelRenderer->renderHit(player, mc->hitResult, 0, player->inventory->getSelected(), a);
 				levelRenderer->renderHitOutline(player, mc->hitResult, 0, player->inventory->getSelected(), a);
@@ -1463,11 +1463,11 @@ void GameRenderer::renderLevel(float a, __int64 until)
 		glEnable(GL_CULL_FACE);
 		glDisable(GL_BLEND);
 
-		if (zoom == 1 && (dynamic_pointer_cast<Player>(cameraEntity)!=NULL)) //&& !mc->options.hideGui)
+		if (zoom == 1 && (std::dynamic_pointer_cast<Player>(cameraEntity)!=NULL)) //&& !mc->options.hideGui)
 		{
 			if (mc->hitResult != NULL && !cameraEntity->isUnderLiquid(Material::water))
 			{
-				std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(cameraEntity);
+				std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(cameraEntity);
 				glDisable(GL_ALPHA_TEST);
 				levelRenderer->renderHit(player, mc->hitResult, 0, player->inventory->getSelected(), a);
 				levelRenderer->renderHitOutline(player, mc->hitResult, 0, player->inventory->getSelected(), a);
@@ -1484,7 +1484,7 @@ void GameRenderer::renderLevel(float a, __int64 until)
 
 		glEnable(GL_BLEND);
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-		levelRenderer->renderDestroyAnimation(Tesselator::getInstance(), dynamic_pointer_cast<Player>(cameraEntity), a);
+		levelRenderer->renderDestroyAnimation(Tesselator::getInstance(), std::dynamic_pointer_cast<Player>(cameraEntity), a);
 		glDisable(GL_BLEND);
 
         if (mc->options->isCloudsOn())
@@ -1981,9 +1981,9 @@ void GameRenderer::setupFog(int i, float alpha)
 
 	// 4J - check for creative mode brought forward from 1.2.3
     bool creative = false;
-    if (dynamic_pointer_cast<Player>(player) )
+    if (std::dynamic_pointer_cast<Player>(player) )
 	{
-        creative = (dynamic_pointer_cast<Player>(player))->abilities.instabuild;
+        creative = (std::dynamic_pointer_cast<Player>(player))->abilities.instabuild;
     }
 
     if (i == 999)
diff --git a/Minecraft.Client/Rendering/LevelRenderer.cpp b/Minecraft.Client/Rendering/LevelRenderer.cpp
index d978868cc..dc239f1d6 100644
--- a/Minecraft.Client/Rendering/LevelRenderer.cpp
+++ b/Minecraft.Client/Rendering/LevelRenderer.cpp
@@ -540,7 +540,7 @@ void LevelRenderer::renderEntities(Vec3 *cam, Culler *culler, float a)
 		{
 			// 4J-PB - changing this to be per player
 			//if (entity == mc->cameraTargetPlayer && !mc->options->thirdPersonView && !mc->cameraTargetPlayer->isSleeping()) continue;
-			std::shared_ptr<LocalPlayer> localplayer = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
+			std::shared_ptr<LocalPlayer> localplayer = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
 
 			if (localplayer && entity == mc->cameraTargetPlayer && !localplayer->ThirdPersonView() && !mc->cameraTargetPlayer->isSleeping()) continue;
 
@@ -2802,7 +2802,7 @@ std::shared_ptr<Particle> LevelRenderer::addParticleInternal(ePARTICLE_TYPE ePar
 		break;
 	case eParticleType_instantSpell:
 		particle = std::shared_ptr<Particle>(new SpellParticle(lev, x, y, z, xa, ya, za));
-		dynamic_pointer_cast<SpellParticle>(particle)->setBaseTex(9 * 16);
+		std::dynamic_pointer_cast<SpellParticle>(particle)->setBaseTex(9 * 16);
 		break;
 	case eParticleType_note:
 		particle = std::shared_ptr<Particle>( new NoteParticle(lev, x, y, z, xa, ya, za) );
@@ -2877,7 +2877,7 @@ std::shared_ptr<Particle> LevelRenderer::addParticleInternal(ePARTICLE_TYPE ePar
 		else if( ( eParticleType >= eParticleType_tilecrack_base ) &&  ( eParticleType <= eParticleType_tilecrack_last )  )
 		{
 			int id = PARTICLE_CRACK_ID(eParticleType), data = PARTICLE_CRACK_DATA(eParticleType);
-			particle = dynamic_pointer_cast<Particle>( std::shared_ptr<TerrainParticle>(new TerrainParticle(lev, x, y, z, xa, ya, za, Tile::tiles[id], 0, data, textures))->init(data) );
+			particle = std::dynamic_pointer_cast<Particle>( std::shared_ptr<TerrainParticle>(new TerrainParticle(lev, x, y, z, xa, ya, za, Tile::tiles[id], 0, data, textures))->init(data) );
 		}
 	}
 
diff --git a/Minecraft.Client/Rendering/Models/DragonModel.cpp b/Minecraft.Client/Rendering/Models/DragonModel.cpp
index 63887a15f..fd189af9d 100644
--- a/Minecraft.Client/Rendering/Models/DragonModel.cpp
+++ b/Minecraft.Client/Rendering/Models/DragonModel.cpp
@@ -114,7 +114,7 @@ void DragonModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r,
 void DragonModel::render(std::shared_ptr<Entity> entity, float time, float r, float bob, float yRot, float xRot, float scale, bool usecompiled)
 {
 	glPushMatrix();
-	std::shared_ptr<EnderDragon> dragon = dynamic_pointer_cast<EnderDragon>(entity);
+	std::shared_ptr<EnderDragon> dragon = std::dynamic_pointer_cast<EnderDragon>(entity);
 
 	float ttt = dragon->oFlapTime + (dragon->flapTime - dragon->oFlapTime) * a;
 	jaw->xRot = (float) (Mth::sin(ttt * PI * 2) + 1) * 0.2f;
diff --git a/Minecraft.Client/Rendering/Models/LavaSlimeModel.cpp b/Minecraft.Client/Rendering/Models/LavaSlimeModel.cpp
index 1407325cf..dec013d5d 100644
--- a/Minecraft.Client/Rendering/Models/LavaSlimeModel.cpp
+++ b/Minecraft.Client/Rendering/Models/LavaSlimeModel.cpp
@@ -43,7 +43,7 @@ int LavaSlimeModel::getModelVersion()
 
 void LavaSlimeModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r, float a) 
 {
-	 std::shared_ptr<LavaSlime> lavaSlime = dynamic_pointer_cast<LavaSlime>(mob);
+	 std::shared_ptr<LavaSlime> lavaSlime = std::dynamic_pointer_cast<LavaSlime>(mob);
 
     float slimeSquish = (lavaSlime->oSquish + (lavaSlime->squish - lavaSlime->oSquish) * a);
     if (slimeSquish < 0) 
diff --git a/Minecraft.Client/Rendering/Models/OcelotModel.cpp b/Minecraft.Client/Rendering/Models/OcelotModel.cpp
index a58647540..6e7bf6388 100644
--- a/Minecraft.Client/Rendering/Models/OcelotModel.cpp
+++ b/Minecraft.Client/Rendering/Models/OcelotModel.cpp
@@ -182,7 +182,7 @@ void OzelotModel::setupAnim(float time, float r, float bob, float yRot, float xR
 
 void OzelotModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r, float a)
 {
-	std::shared_ptr<Ozelot> ozelot = dynamic_pointer_cast<Ozelot>(mob);
+	std::shared_ptr<Ozelot> ozelot = std::dynamic_pointer_cast<Ozelot>(mob);
 
 	body->y = bodyWalkY;
 	body->z = bodyWalkZ;
diff --git a/Minecraft.Client/Rendering/Models/SheepFurModel.cpp b/Minecraft.Client/Rendering/Models/SheepFurModel.cpp
index 4bc4e935b..4f6498577 100644
--- a/Minecraft.Client/Rendering/Models/SheepFurModel.cpp
+++ b/Minecraft.Client/Rendering/Models/SheepFurModel.cpp
@@ -45,7 +45,7 @@ void SheepFurModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float
 {
 	QuadrupedModel::prepareMobModel(mob, time, r, a);
 
-	std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(mob);
+	std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(mob);
 	head->y = 6 + sheep->getHeadEatPositionScale(a) * 9.0f;
 	headXRot = sheep->getHeadEatAngleScale(a);
 }
diff --git a/Minecraft.Client/Rendering/Models/SheepModel.cpp b/Minecraft.Client/Rendering/Models/SheepModel.cpp
index 3c1af09a0..fdd4eb230 100644
--- a/Minecraft.Client/Rendering/Models/SheepModel.cpp
+++ b/Minecraft.Client/Rendering/Models/SheepModel.cpp
@@ -24,7 +24,7 @@ void SheepModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r,
 {
 	QuadrupedModel::prepareMobModel(mob, time, r, a);
 
-	std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(mob);
+	std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(mob);
 	head->y = 6 + sheep->getHeadEatPositionScale(a) * 9.0f;
 	headXRot = sheep->getHeadEatAngleScale(a);
 }
diff --git a/Minecraft.Client/Rendering/Models/VillagerGolemModel.cpp b/Minecraft.Client/Rendering/Models/VillagerGolemModel.cpp
index 0e5308038..e8e120b70 100644
--- a/Minecraft.Client/Rendering/Models/VillagerGolemModel.cpp
+++ b/Minecraft.Client/Rendering/Models/VillagerGolemModel.cpp
@@ -61,7 +61,7 @@ void VillagerGolemModel::setupAnim(float time, float r, float bob, float yRot, f
 
 void VillagerGolemModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r, float a)
 {
-	std::shared_ptr<VillagerGolem> vg = dynamic_pointer_cast<VillagerGolem>(mob);
+	std::shared_ptr<VillagerGolem> vg = std::dynamic_pointer_cast<VillagerGolem>(mob);
 	int attackTick = vg->getAttackAnimationTick();
 	if (attackTick > 0)
 	{
diff --git a/Minecraft.Client/Rendering/Models/WolfModel.cpp b/Minecraft.Client/Rendering/Models/WolfModel.cpp
index b822fce04..b58344b24 100644
--- a/Minecraft.Client/Rendering/Models/WolfModel.cpp
+++ b/Minecraft.Client/Rendering/Models/WolfModel.cpp
@@ -96,7 +96,7 @@ void WolfModel::render(std::shared_ptr<Entity> entity, float time, float r, floa
 
 void WolfModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r, float a)
 {
-    std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(mob);
+    std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(mob);
 
     if (wolf->isAngry())
 	{
diff --git a/Minecraft.Client/Rendering/Particles/Particle.cpp b/Minecraft.Client/Rendering/Particles/Particle.cpp
index 3b5fd697c..203abcafa 100644
--- a/Minecraft.Client/Rendering/Particles/Particle.cpp
+++ b/Minecraft.Client/Rendering/Particles/Particle.cpp
@@ -66,14 +66,14 @@ std::shared_ptr<Particle> Particle::setPower(float power)
     xd *= power;
     yd = (yd - 0.1f) * power + 0.1f;
     zd *= power;
-    return dynamic_pointer_cast<Particle>( shared_from_this() );
+    return std::dynamic_pointer_cast<Particle>( shared_from_this() );
 }
 
 std::shared_ptr<Particle> Particle::scale(float scale)
 {
     setSize(0.2f * scale, 0.2f * scale);
     size *= scale;
-    return dynamic_pointer_cast<Particle>( shared_from_this() );
+    return std::dynamic_pointer_cast<Particle>( shared_from_this() );
 }
 
 void Particle::setColor(float r, float g, float b)
diff --git a/Minecraft.Client/Rendering/Particles/TerrainParticle.cpp b/Minecraft.Client/Rendering/Particles/TerrainParticle.cpp
index 3dca572cf..505e852e6 100644
--- a/Minecraft.Client/Rendering/Particles/TerrainParticle.cpp
+++ b/Minecraft.Client/Rendering/Particles/TerrainParticle.cpp
@@ -16,22 +16,22 @@ TerrainParticle::TerrainParticle(Level *level, double x, double y, double z, dou
 
 std::shared_ptr<TerrainParticle> TerrainParticle::init(int x, int y, int z, int data)	// 4J - added data parameter
 {
-    if (tile == Tile::grass) return dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
+    if (tile == Tile::grass) return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
     int col = tile->getColor(level, x, y, z, data);	// 4J - added data parameter
     rCol *= ((col >> 16) & 0xff) / 255.0f;
     gCol *= ((col >> 8) & 0xff) / 255.0f;
     bCol *= ((col) & 0xff) / 255.0f;
-    return dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
+    return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
 }
 
 std::shared_ptr<TerrainParticle> TerrainParticle::init(int data)
 {
-	if (tile == Tile::grass) return dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
+	if (tile == Tile::grass) return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
 	int col = tile->getColor(data);
 	rCol *= ((col >> 16) & 0xff) / 255.0f;
 	gCol *= ((col >> 8) & 0xff) / 255.0f;
 	bCol *= ((col) & 0xff) / 255.0f;
-	return dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
+	return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
 }
 
 int TerrainParticle::getParticleTexture()
diff --git a/Minecraft.Client/UI/Screens/CraftingScreen.cpp b/Minecraft.Client/UI/Screens/CraftingScreen.cpp
index 631a661d3..3fd956417 100644
--- a/Minecraft.Client/UI/Screens/CraftingScreen.cpp
+++ b/Minecraft.Client/UI/Screens/CraftingScreen.cpp
@@ -11,7 +11,7 @@ CraftingScreen::CraftingScreen(std::shared_ptr<Inventory> inventory, Level *leve
 void CraftingScreen::removed()
 {
     AbstractContainerScreen::removed();
-    menu->removed(dynamic_pointer_cast<Player>(minecraft->player));
+    menu->removed(std::dynamic_pointer_cast<Player>(minecraft->player));
 }
 
 void CraftingScreen::renderLabels()
diff --git a/Minecraft.World/AI/Control/LookControl.cpp b/Minecraft.World/AI/Control/LookControl.cpp
index f17a43298..e9e6c20e3 100644
--- a/Minecraft.World/AI/Control/LookControl.cpp
+++ b/Minecraft.World/AI/Control/LookControl.cpp
@@ -16,7 +16,7 @@ LookControl::LookControl(Mob *mob)
 void LookControl::setLookAt(std::shared_ptr<Entity> target, float yMax, float xMax)
 {
 	this->wantedX = target->x;
-	std::shared_ptr<Mob> targetMob = dynamic_pointer_cast<Mob>(target);
+	std::shared_ptr<Mob> targetMob = std::dynamic_pointer_cast<Mob>(target);
 	if (targetMob != NULL) this->wantedY = target->y + targetMob->getHeadHeight();
 	else this->wantedY = (target->bb->y0 + target->bb->y1) / 2;
 	this->wantedZ = target->z;
diff --git a/Minecraft.World/AI/Goals/ArrowAttackGoal.cpp b/Minecraft.World/AI/Goals/ArrowAttackGoal.cpp
index 8917d87b0..79a01569d 100644
--- a/Minecraft.World/AI/Goals/ArrowAttackGoal.cpp
+++ b/Minecraft.World/AI/Goals/ArrowAttackGoal.cpp
@@ -72,13 +72,13 @@ void ArrowAttackGoal::fireAtTarget()
 	std::shared_ptr<Mob> tar = target.lock();
 	if (projectileType == ArrowType)
 	{
-		std::shared_ptr<Arrow> arrow = std::shared_ptr<Arrow>( new Arrow(level, dynamic_pointer_cast<Mob>(mob->shared_from_this()), tar, 1.60f, 12) );
+		std::shared_ptr<Arrow> arrow = std::shared_ptr<Arrow>( new Arrow(level, std::dynamic_pointer_cast<Mob>(mob->shared_from_this()), tar, 1.60f, 12) );
 		level->playSound(mob->shared_from_this(), eSoundType_RANDOM_BOW, 1.0f, 1 / (mob->getRandom()->nextFloat() * 0.4f + 0.8f));
 		level->addEntity(arrow);
 	}
 	else if (projectileType == SnowballType)
 	{
-		std::shared_ptr<Snowball> snowball = std::shared_ptr<Snowball>( new Snowball(level, dynamic_pointer_cast<Mob>(mob->shared_from_this())) );
+		std::shared_ptr<Snowball> snowball = std::shared_ptr<Snowball>( new Snowball(level, std::dynamic_pointer_cast<Mob>(mob->shared_from_this())) );
 		double xd = tar->x - mob->x;
 		double yd = (tar->y + tar->getHeadHeight() - 1.1f) - snowball->y;
 		double zd = tar->z - mob->z;
diff --git a/Minecraft.World/AI/Goals/AvoidPlayerGoal.cpp b/Minecraft.World/AI/Goals/AvoidPlayerGoal.cpp
index 5aafb0897..91554b3fe 100644
--- a/Minecraft.World/AI/Goals/AvoidPlayerGoal.cpp
+++ b/Minecraft.World/AI/Goals/AvoidPlayerGoal.cpp
@@ -33,7 +33,7 @@ bool AvoidPlayerGoal::canUse()
 {
 	if (avoidType == typeid(Player))
 	{
-		std::shared_ptr<TamableAnimal> tamableAnimal = dynamic_pointer_cast<TamableAnimal>(mob->shared_from_this());
+		std::shared_ptr<TamableAnimal> tamableAnimal = std::dynamic_pointer_cast<TamableAnimal>(mob->shared_from_this());
 		if (tamableAnimal != NULL && tamableAnimal->isTame()) return false;
 		toAvoid = std::weak_ptr<Entity>(mob->level->getNearestPlayer(mob->shared_from_this(), maxDist));
 		if (toAvoid.lock() == NULL) return false;
@@ -52,7 +52,7 @@ bool AvoidPlayerGoal::canUse()
 
 	if (!mob->getSensing()->canSee(toAvoid.lock())) return false;
 
-	Vec3 *pos = RandomPos::getPosAvoid(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(toAvoid.lock()->x, toAvoid.lock()->y, toAvoid.lock()->z));
+	Vec3 *pos = RandomPos::getPosAvoid(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(toAvoid.lock()->x, toAvoid.lock()->y, toAvoid.lock()->z));
 	if (pos == NULL) return false;
 	if (toAvoid.lock()->distanceToSqr(pos->x, pos->y, pos->z) < toAvoid.lock()->distanceToSqr(mob->shared_from_this())) return false;
 	delete path;
diff --git a/Minecraft.World/AI/Goals/BreedGoal.cpp b/Minecraft.World/AI/Goals/BreedGoal.cpp
index a3ea9c3a9..e7708951f 100644
--- a/Minecraft.World/AI/Goals/BreedGoal.cpp
+++ b/Minecraft.World/AI/Goals/BreedGoal.cpp
@@ -52,7 +52,7 @@ std::shared_ptr<Animal> BreedGoal::getFreePartner()
 	std::vector<std::shared_ptr<Entity> > *others = level->getEntitiesOfClass(typeid(*animal), animal->bb->grow(r, r, r));
 	for(AUTO_VAR(it, others->begin()); it != others->end(); ++it)
 	{
-		std::shared_ptr<Animal> p = dynamic_pointer_cast<Animal>(*it);
+		std::shared_ptr<Animal> p = std::dynamic_pointer_cast<Animal>(*it);
 		if (animal->canMate(p))
 		{
 			delete others;
diff --git a/Minecraft.World/AI/Goals/ControlledByPlayerGoal.cpp b/Minecraft.World/AI/Goals/ControlledByPlayerGoal.cpp
index 9c9d666ac..b05cfac4e 100644
--- a/Minecraft.World/AI/Goals/ControlledByPlayerGoal.cpp
+++ b/Minecraft.World/AI/Goals/ControlledByPlayerGoal.cpp
@@ -36,13 +36,13 @@ void ControlledByPlayerGoal::stop()
 
 bool ControlledByPlayerGoal::canUse()
 {
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( mob->rider.lock() );
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( mob->rider.lock() );
 	return mob->isAlive() && player && (boosting || mob->canBeControlledByRider());
 }
 
 void ControlledByPlayerGoal::tick()
 {
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob->rider.lock());
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mob->rider.lock());
 	PathfinderMob *pig = (PathfinderMob *)mob;
 
 	float yrd = Mth::wrapDegrees(player->yRot - mob->yRot) * 0.5f;
diff --git a/Minecraft.World/AI/Goals/DefendVillageTargetGoal.cpp b/Minecraft.World/AI/Goals/DefendVillageTargetGoal.cpp
index 710d3b840..14ffa6dbe 100644
--- a/Minecraft.World/AI/Goals/DefendVillageTargetGoal.cpp
+++ b/Minecraft.World/AI/Goals/DefendVillageTargetGoal.cpp
@@ -13,7 +13,7 @@ bool DefendVillageTargetGoal::canUse()
 {
 	std::shared_ptr<Village> village = golem->getVillage();
 	if (village == NULL) return false;
-	potentialTarget = std::weak_ptr<Mob>(village->getClosestAggressor(dynamic_pointer_cast<Mob>(golem->shared_from_this())));
+	potentialTarget = std::weak_ptr<Mob>(village->getClosestAggressor(std::dynamic_pointer_cast<Mob>(golem->shared_from_this())));
 	return canAttack(potentialTarget.lock(), false);
 }
 
diff --git a/Minecraft.World/AI/Goals/FollowParentGoal.cpp b/Minecraft.World/AI/Goals/FollowParentGoal.cpp
index a0d9f207d..d6bc78561 100644
--- a/Minecraft.World/AI/Goals/FollowParentGoal.cpp
+++ b/Minecraft.World/AI/Goals/FollowParentGoal.cpp
@@ -24,7 +24,7 @@ bool FollowParentGoal::canUse()
 	double closestDistSqr = Double::MAX_VALUE;
 	for(AUTO_VAR(it, parents->begin()); it != parents->end(); ++it)
 	{
-		std::shared_ptr<Animal> parent = dynamic_pointer_cast<Animal>(*it);
+		std::shared_ptr<Animal> parent = std::dynamic_pointer_cast<Animal>(*it);
 		if (parent->getAge() < 0) continue;
 		double distSqr = animal->distanceToSqr(parent);
 		if (distSqr > closestDistSqr) continue;
diff --git a/Minecraft.World/AI/Goals/HurtByTargetGoal.cpp b/Minecraft.World/AI/Goals/HurtByTargetGoal.cpp
index 4ddcb5ddd..0bf600029 100644
--- a/Minecraft.World/AI/Goals/HurtByTargetGoal.cpp
+++ b/Minecraft.World/AI/Goals/HurtByTargetGoal.cpp
@@ -25,7 +25,7 @@ void HurtByTargetGoal::start()
 		std::vector<std::shared_ptr<Entity> > *nearby = mob->level->getEntitiesOfClass(typeid(*mob), AABB::newTemp(mob->x, mob->y, mob->z, mob->x + 1, mob->y + 1, mob->z + 1)->grow(within, 4, within));
 		for(AUTO_VAR(it, nearby->begin()); it != nearby->end(); ++it)
 		{
-			std::shared_ptr<Mob> other = dynamic_pointer_cast<Mob>(*it);
+			std::shared_ptr<Mob> other = std::dynamic_pointer_cast<Mob>(*it);
 			if (this->mob->shared_from_this() == other) continue;
 			if (other->getTarget() != NULL) continue;
 			other->setTarget(mob->getLastHurtByMob());
diff --git a/Minecraft.World/AI/Goals/LookAtTradingPlayerGoal.cpp b/Minecraft.World/AI/Goals/LookAtTradingPlayerGoal.cpp
index f7393f2ce..7d8bfc92b 100644
--- a/Minecraft.World/AI/Goals/LookAtTradingPlayerGoal.cpp
+++ b/Minecraft.World/AI/Goals/LookAtTradingPlayerGoal.cpp
@@ -12,7 +12,7 @@ bool LookAtTradingPlayerGoal::canUse()
 {
 	if (villager->isTrading())
 	{
-		lookAt = std::weak_ptr<Entity>(dynamic_pointer_cast<Entity>(villager->getTradingPlayer()));
+		lookAt = std::weak_ptr<Entity>(std::dynamic_pointer_cast<Entity>(villager->getTradingPlayer()));
 		return true;
 	}
 	return false;
diff --git a/Minecraft.World/AI/Goals/MakeLoveGoal.cpp b/Minecraft.World/AI/Goals/MakeLoveGoal.cpp
index 8cb482591..2f7a7323a 100644
--- a/Minecraft.World/AI/Goals/MakeLoveGoal.cpp
+++ b/Minecraft.World/AI/Goals/MakeLoveGoal.cpp
@@ -32,7 +32,7 @@ bool MakeLoveGoal::canUse()
 	std::shared_ptr<Entity> mate = level->getClosestEntityOfClass(typeid(Villager), villager->bb->grow(8, 3, 8), villager->shared_from_this());
 	if (mate == NULL) return false;
 
-	partner = std::weak_ptr<Villager>(dynamic_pointer_cast<Villager>(mate));
+	partner = std::weak_ptr<Villager>(std::dynamic_pointer_cast<Villager>(mate));
 	if (partner.lock()->getAge() != 0) return false;
 
 	return true;
diff --git a/Minecraft.World/AI/Goals/MoveIndoorsGoal.cpp b/Minecraft.World/AI/Goals/MoveIndoorsGoal.cpp
index 7ecd02607..c40300e7d 100644
--- a/Minecraft.World/AI/Goals/MoveIndoorsGoal.cpp
+++ b/Minecraft.World/AI/Goals/MoveIndoorsGoal.cpp
@@ -44,7 +44,7 @@ void MoveIndoorsGoal::start()
 	}
 	if (mob->distanceToSqr(_doorInfo->getIndoorX(), _doorInfo->y, _doorInfo->getIndoorZ()) > 16 * 16)
 	{
-		Vec3 *pos = RandomPos::getPosTowards(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 14, 3, Vec3::newTemp(_doorInfo->getIndoorX() + 0.5, _doorInfo->getIndoorY(), _doorInfo->getIndoorZ() + 0.5));
+		Vec3 *pos = RandomPos::getPosTowards(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 14, 3, Vec3::newTemp(_doorInfo->getIndoorX() + 0.5, _doorInfo->getIndoorY(), _doorInfo->getIndoorZ() + 0.5));
 		if (pos != NULL) mob->getNavigation()->moveTo(pos->x, pos->y, pos->z, 0.3f);
 	}
 	else mob->getNavigation()->moveTo(_doorInfo->getIndoorX() + 0.5, _doorInfo->getIndoorY(), _doorInfo->getIndoorZ() + 0.5, 0.3f);
diff --git a/Minecraft.World/AI/Goals/MoveThroughVillageGoal.cpp b/Minecraft.World/AI/Goals/MoveThroughVillageGoal.cpp
index dd32e2fe8..0340d1e3f 100644
--- a/Minecraft.World/AI/Goals/MoveThroughVillageGoal.cpp
+++ b/Minecraft.World/AI/Goals/MoveThroughVillageGoal.cpp
@@ -46,7 +46,7 @@ bool MoveThroughVillageGoal::canUse()
 	mob->getNavigation()->setCanOpenDoors(oldCanOpenDoors);
 	if (path != NULL) return true;
 
-	Vec3 *pos = RandomPos::getPosTowards(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7, Vec3::newTemp(_doorInfo->x, _doorInfo->y, _doorInfo->z));
+	Vec3 *pos = RandomPos::getPosTowards(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7, Vec3::newTemp(_doorInfo->x, _doorInfo->y, _doorInfo->z));
 	if (pos == NULL) return false;
 	mob->getNavigation()->setCanOpenDoors(false);
 	delete path;
diff --git a/Minecraft.World/AI/Goals/MoveTowardsRestrictionGoal.cpp b/Minecraft.World/AI/Goals/MoveTowardsRestrictionGoal.cpp
index 32aaea444..edac22049 100644
--- a/Minecraft.World/AI/Goals/MoveTowardsRestrictionGoal.cpp
+++ b/Minecraft.World/AI/Goals/MoveTowardsRestrictionGoal.cpp
@@ -19,7 +19,7 @@ bool MoveTowardsRestrictionGoal::canUse()
 {
 	if (mob->isWithinRestriction()) return false;
 	Pos *towards = mob->getRestrictCenter();
-	Vec3 *pos = RandomPos::getPosTowards(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(towards->x, towards->y, towards->z));
+	Vec3 *pos = RandomPos::getPosTowards(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(towards->x, towards->y, towards->z));
 	if (pos == NULL) return false;
 	wantedX = pos->x;
 	wantedY = pos->y;
diff --git a/Minecraft.World/AI/Goals/MoveTowardsTargetGoal.cpp b/Minecraft.World/AI/Goals/MoveTowardsTargetGoal.cpp
index c9c43ffd1..4f89fdaf1 100644
--- a/Minecraft.World/AI/Goals/MoveTowardsTargetGoal.cpp
+++ b/Minecraft.World/AI/Goals/MoveTowardsTargetGoal.cpp
@@ -19,7 +19,7 @@ bool MoveTowardsTargetGoal::canUse()
 	target = std::weak_ptr<Mob>(mob->getTarget());
 	if (target.lock() == NULL) return false;
 	if (target.lock()->distanceToSqr(mob->shared_from_this()) > within * within) return false;
-	Vec3 *pos = RandomPos::getPosTowards(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(target.lock()->x, target.lock()->y, target.lock()->z));
+	Vec3 *pos = RandomPos::getPosTowards(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(target.lock()->x, target.lock()->y, target.lock()->z));
 	if (pos == NULL) return false;
 	wantedX = pos->x;
 	wantedY = pos->y;
diff --git a/Minecraft.World/AI/Goals/NearestAttackableTargetGoal.cpp b/Minecraft.World/AI/Goals/NearestAttackableTargetGoal.cpp
index 306091024..40045f385 100644
--- a/Minecraft.World/AI/Goals/NearestAttackableTargetGoal.cpp
+++ b/Minecraft.World/AI/Goals/NearestAttackableTargetGoal.cpp
@@ -52,7 +52,7 @@ bool NearestAttackableTargetGoal::canUse()
 		std::sort(entities->begin(), entities->end(), *distComp);
 		for(AUTO_VAR(it, entities->begin()); it != entities->end(); ++it)
 		{
-			std::shared_ptr<Mob> potTarget = dynamic_pointer_cast<Mob>(*it);
+			std::shared_ptr<Mob> potTarget = std::dynamic_pointer_cast<Mob>(*it);
 			if (canAttack(potTarget, false))
 			{
 				target = std::weak_ptr<Mob>(potTarget);
diff --git a/Minecraft.World/AI/Goals/OcelotSitOnTileGoal.cpp b/Minecraft.World/AI/Goals/OcelotSitOnTileGoal.cpp
index 280da8c70..10ad295c0 100644
--- a/Minecraft.World/AI/Goals/OcelotSitOnTileGoal.cpp
+++ b/Minecraft.World/AI/Goals/OcelotSitOnTileGoal.cpp
@@ -107,7 +107,7 @@ bool OcelotSitOnTileGoal::isValidTarget(Level *level, int x, int y, int z)
 
 	if (tile == Tile::chest_Id)
 	{
-		std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z));
+		std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z));
 
 		if (chest->openCount < 1)
 		{
diff --git a/Minecraft.World/AI/Goals/OfferFlowerGoal.cpp b/Minecraft.World/AI/Goals/OfferFlowerGoal.cpp
index c4090bbe7..8e5ca3f90 100644
--- a/Minecraft.World/AI/Goals/OfferFlowerGoal.cpp
+++ b/Minecraft.World/AI/Goals/OfferFlowerGoal.cpp
@@ -16,7 +16,7 @@ bool OfferFlowerGoal::canUse()
 {
 	if (!golem->level->isDay()) return false;
 	if (golem->getRandom()->nextInt(8000) != 0) return false;
-	villager = std::weak_ptr<Villager>(dynamic_pointer_cast<Villager>( golem->level->getClosestEntityOfClass(typeid(Villager), golem->bb->grow(6, 2, 6), golem->shared_from_this()) ));
+	villager = std::weak_ptr<Villager>(std::dynamic_pointer_cast<Villager>( golem->level->getClosestEntityOfClass(typeid(Villager), golem->bb->grow(6, 2, 6), golem->shared_from_this()) ));
 	return villager.lock() != NULL;
 }
 
diff --git a/Minecraft.World/AI/Goals/PanicGoal.cpp b/Minecraft.World/AI/Goals/PanicGoal.cpp
index 2b0a04ee2..8761c19ab 100644
--- a/Minecraft.World/AI/Goals/PanicGoal.cpp
+++ b/Minecraft.World/AI/Goals/PanicGoal.cpp
@@ -16,7 +16,7 @@ PanicGoal::PanicGoal(PathfinderMob *mob, float speed)
 bool PanicGoal::canUse()
 {
 	if (mob->getLastHurtByMob() == NULL) return false;
-	Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 5, 4);
+	Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 5, 4);
 	if (pos == NULL) return false;
 	posX = pos->x;
 	posY = pos->y;
diff --git a/Minecraft.World/AI/Goals/PlayGoal.cpp b/Minecraft.World/AI/Goals/PlayGoal.cpp
index 2d6ebb992..e9efb1557 100644
--- a/Minecraft.World/AI/Goals/PlayGoal.cpp
+++ b/Minecraft.World/AI/Goals/PlayGoal.cpp
@@ -32,7 +32,7 @@ bool PlayGoal::canUse()
 	{
 		std::shared_ptr<Entity> c = *it;
 		if (c.get() == mob) continue;
-		std::shared_ptr<Villager> friendV = dynamic_pointer_cast<Villager>(c);
+		std::shared_ptr<Villager> friendV = std::dynamic_pointer_cast<Villager>(c);
 		if (friendV->isChasing()) continue;
 		if (friendV->getAge() >= 0) continue;
 		double distSqr = friendV->distanceToSqr(mob->shared_from_this());
@@ -44,7 +44,7 @@ bool PlayGoal::canUse()
 
 	if (followFriend.lock() == NULL)
 	{
-		Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 3);
+		Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 3);
 		if (pos == NULL) return false;
 	}
 	return true;
@@ -78,7 +78,7 @@ void PlayGoal::tick()
 	{
 		if (mob->getNavigation()->isDone())
 		{
-			Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 3);
+			Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 3);
 			if (pos == NULL) return;
 			mob->getNavigation()->moveTo(pos->x, pos->y, pos->z, speed);
 		}
diff --git a/Minecraft.World/AI/Goals/RandomStrollGoal.cpp b/Minecraft.World/AI/Goals/RandomStrollGoal.cpp
index 4bc3e0cf1..0d229d5d7 100644
--- a/Minecraft.World/AI/Goals/RandomStrollGoal.cpp
+++ b/Minecraft.World/AI/Goals/RandomStrollGoal.cpp
@@ -21,7 +21,7 @@ bool RandomStrollGoal::canUse()
 	{
 		if (mob->getRandom()->nextInt(120) == 0)
 		{
-			Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7);
+			Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7);
 			if (pos == NULL) return false;
 			wantedX = pos->x;
 			wantedY = pos->y;
@@ -37,7 +37,7 @@ bool RandomStrollGoal::canUse()
 
 		if( mob->isExtraWanderingEnabled() )
 		{
-			Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7,mob->getWanderingQuadrant());
+			Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7,mob->getWanderingQuadrant());
 			if (pos == NULL) return false;
 			wantedX = pos->x;
 			wantedY = pos->y;
diff --git a/Minecraft.World/AI/Goals/TakeFlowerGoal.cpp b/Minecraft.World/AI/Goals/TakeFlowerGoal.cpp
index 3959a3308..7f31d72bc 100644
--- a/Minecraft.World/AI/Goals/TakeFlowerGoal.cpp
+++ b/Minecraft.World/AI/Goals/TakeFlowerGoal.cpp
@@ -33,7 +33,7 @@ bool TakeFlowerGoal::canUse()
 	//for (Entity e : golems)
 	for(AUTO_VAR(it,golems->begin()); it != golems->end(); ++it)
 	{
-		std::shared_ptr<VillagerGolem> vg = dynamic_pointer_cast<VillagerGolem>(*it);
+		std::shared_ptr<VillagerGolem> vg = std::dynamic_pointer_cast<VillagerGolem>(*it);
 		if (vg->getOfferFlowerTick() > 0)
 		{
 			golem = std::weak_ptr<VillagerGolem>(vg);
diff --git a/Minecraft.World/AI/Goals/TargetGoal.cpp b/Minecraft.World/AI/Goals/TargetGoal.cpp
index 0fdd880c1..7936cfac5 100644
--- a/Minecraft.World/AI/Goals/TargetGoal.cpp
+++ b/Minecraft.World/AI/Goals/TargetGoal.cpp
@@ -69,16 +69,16 @@ bool TargetGoal::canAttack(std::shared_ptr<Mob> target, bool allowInvulnerable)
 	if (!target->isAlive()) return false;
 	if (!mob->canAttackType(target->GetType())) return false;
 
-	std::shared_ptr<TamableAnimal> tamableAnimal = dynamic_pointer_cast<TamableAnimal>(mob->shared_from_this());
+	std::shared_ptr<TamableAnimal> tamableAnimal = std::dynamic_pointer_cast<TamableAnimal>(mob->shared_from_this());
 	if (tamableAnimal != NULL && tamableAnimal->isTame())
 	{
-		std::shared_ptr<TamableAnimal> tamableTarget = dynamic_pointer_cast<TamableAnimal>(target);
+		std::shared_ptr<TamableAnimal> tamableTarget = std::dynamic_pointer_cast<TamableAnimal>(target);
 		if (tamableTarget != NULL && tamableTarget->isTame()) return false;
 		if (target == tamableAnimal->getOwner()) return false;
 	}
-	else if (dynamic_pointer_cast<Player>(target) != NULL)
+	else if (std::dynamic_pointer_cast<Player>(target) != NULL)
 	{
-		if (!allowInvulnerable && (dynamic_pointer_cast<Player>(target))->abilities.invulnerable) return false;
+		if (!allowInvulnerable && (std::dynamic_pointer_cast<Player>(target))->abilities.invulnerable) return false;
 	}
 
 	if (!mob->isWithinRestriction(Mth::floor(target->x), Mth::floor(target->y), Mth::floor(target->z))) return false;
diff --git a/Minecraft.World/Blocks/BrewingStandTile.cpp b/Minecraft.World/Blocks/BrewingStandTile.cpp
index 0ecdc6d0a..0a54ac583 100644
--- a/Minecraft.World/Blocks/BrewingStandTile.cpp
+++ b/Minecraft.World/Blocks/BrewingStandTile.cpp
@@ -60,7 +60,7 @@ bool BrewingStandTile::use(Level *level, int x, int y, int z, std::shared_ptr<Pl
 	{
         return true;
     }
-    std::shared_ptr<BrewingStandTileEntity> brewingStand = dynamic_pointer_cast<BrewingStandTileEntity>(level->getTileEntity(x, y, z));
+    std::shared_ptr<BrewingStandTileEntity> brewingStand = std::dynamic_pointer_cast<BrewingStandTileEntity>(level->getTileEntity(x, y, z));
     if (brewingStand != NULL) player->openBrewingStand(brewingStand);
 
 	return true;
@@ -79,9 +79,9 @@ void BrewingStandTile::animateTick(Level *level, int xt, int yt, int zt, Random
 void BrewingStandTile::onRemove(Level *level, int x, int y, int z, int id, int data)
 {
     std::shared_ptr<TileEntity> tileEntity = level->getTileEntity(x, y, z);
-    if (tileEntity != NULL && ( dynamic_pointer_cast<BrewingStandTileEntity>(tileEntity) != NULL) )
+    if (tileEntity != NULL && ( std::dynamic_pointer_cast<BrewingStandTileEntity>(tileEntity) != NULL) )
 	{
-        std::shared_ptr<BrewingStandTileEntity> container = dynamic_pointer_cast<BrewingStandTileEntity>(tileEntity);
+        std::shared_ptr<BrewingStandTileEntity> container = std::dynamic_pointer_cast<BrewingStandTileEntity>(tileEntity);
         for (int i = 0; i < container->getContainerSize(); i++)
 		{
             std::shared_ptr<ItemInstance> item = container->getItem(i);
diff --git a/Minecraft.World/Blocks/CauldronTile.cpp b/Minecraft.World/Blocks/CauldronTile.cpp
index 1e2fdc637..475f8bd7d 100644
--- a/Minecraft.World/Blocks/CauldronTile.cpp
+++ b/Minecraft.World/Blocks/CauldronTile.cpp
@@ -123,9 +123,9 @@ bool CauldronTile::use(Level *level, int x, int y, int z, std::shared_ptr<Player
                 level->addEntity(std::shared_ptr<ItemEntity>(new ItemEntity(level, x + 0.5, y + 1.5, z + 0.5, potion)));
             }
 			// 4J Stu - Brought forward change to update inventory when filling bottles with water
-			else if (dynamic_pointer_cast<ServerPlayer>( player ) != NULL)
+			else if (std::dynamic_pointer_cast<ServerPlayer>( player ) != NULL)
 			{
-				dynamic_pointer_cast<ServerPlayer>( player )->refreshContainer(player->inventoryMenu);
+				std::dynamic_pointer_cast<ServerPlayer>( player )->refreshContainer(player->inventoryMenu);
 			}
 			// 4J-PB - don't lose the water in creative mode
 			if (player->abilities.instabuild==false)
diff --git a/Minecraft.World/Blocks/ChestTile.cpp b/Minecraft.World/Blocks/ChestTile.cpp
index 04924921b..f94256157 100644
--- a/Minecraft.World/Blocks/ChestTile.cpp
+++ b/Minecraft.World/Blocks/ChestTile.cpp
@@ -200,13 +200,13 @@ bool ChestTile::isFullChest(Level *level, int x, int y, int z)
 void ChestTile::neighborChanged(Level *level, int x, int y, int z, int type)
 {
     EntityTile::neighborChanged(level, x, y, z, type);
-    std::shared_ptr<ChestTileEntity>(cte) = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z));
+    std::shared_ptr<ChestTileEntity>(cte) = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z));
     if (cte != NULL) cte->clearCache();
 }
 
 void ChestTile::onRemove(Level *level, int x, int y, int z, int id, int data)
 {
-    std::shared_ptr<Container> container = dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z) );
+    std::shared_ptr<Container> container = std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z) );
 	if (container != NULL )
 	{
 		for (unsigned int i = 0; i < container->getContainerSize(); i++)
@@ -263,7 +263,7 @@ bool ChestTile::use(Level *level, int x, int y, int z, std::shared_ptr<Player> p
         return true;
     }
 
-    std::shared_ptr<Container> container = dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z) );
+    std::shared_ptr<Container> container = std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z) );
 	if (container == NULL) return true;
 
 	if (level->isSolidBlockingTile(x, y + 1, z)) return true;
@@ -274,10 +274,10 @@ bool ChestTile::use(Level *level, int x, int y, int z, std::shared_ptr<Player> p
     if (level->getTile(x, y, z - 1) == id && (level->isSolidBlockingTile(x, y + 1, z - 1) || isCatSittingOnChest(level, x, y, z - 1))) return true;
     if (level->getTile(x, y, z + 1) == id && (level->isSolidBlockingTile(x, y + 1, z + 1) || isCatSittingOnChest(level, x, y, z + 1))) return true;
 
-    if (level->getTile(x - 1, y, z) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x - 1, y, z) ), container) );
-    if (level->getTile(x + 1, y, z) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, container, dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x + 1, y, z) )) );
-    if (level->getTile(x, y, z - 1) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z - 1) ), container) );
-    if (level->getTile(x, y, z + 1) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, container, dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z + 1) )) );
+    if (level->getTile(x - 1, y, z) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x - 1, y, z) ), container) );
+    if (level->getTile(x + 1, y, z) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, container, std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x + 1, y, z) )) );
+    if (level->getTile(x, y, z - 1) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z - 1) ), container) );
+    if (level->getTile(x, y, z + 1) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, container, std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z + 1) )) );
 
     player->openContainer(container);
 
@@ -290,7 +290,7 @@ bool ChestTile::isCatSittingOnChest(Level *level, int x, int y, int z)
 	std::vector<std::shared_ptr<Entity> > *entities = level->getEntitiesOfClass(typeid(Ozelot), AABB::newTemp(x, y + 1, z, x + 1, y + 2, z + 1));
 	for(AUTO_VAR(it, entities->begin()); it != entities->end(); ++it)
 	{
-		std::shared_ptr<Ozelot> ocelot = dynamic_pointer_cast<Ozelot>(*it);
+		std::shared_ptr<Ozelot> ocelot = std::dynamic_pointer_cast<Ozelot>(*it);
 		if(ocelot->isSitting())
 		{
 			return true;
diff --git a/Minecraft.World/Blocks/DispenserTile.cpp b/Minecraft.World/Blocks/DispenserTile.cpp
index 4a7eda55c..d10e04db6 100644
--- a/Minecraft.World/Blocks/DispenserTile.cpp
+++ b/Minecraft.World/Blocks/DispenserTile.cpp
@@ -107,7 +107,7 @@ bool DispenserTile::use(Level *level, int x, int y, int z, std::shared_ptr<Playe
 		return true;
 	}
 
-	std::shared_ptr<DispenserTileEntity> trap = dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) );
+	std::shared_ptr<DispenserTileEntity> trap = std::dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) );
 	player->openTrap(trap);
 
 	return true;
@@ -138,7 +138,7 @@ void DispenserTile::fireArrow(Level *level, int x, int y, int z, Random *random)
 		xd = -1;
 	}
 
-	std::shared_ptr<DispenserTileEntity> trap = dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) );
+	std::shared_ptr<DispenserTileEntity> trap = std::dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) );
 	if(trap != NULL)
 	{
 		int slot=trap->getRandomSlot();
@@ -207,7 +207,7 @@ void DispenserTile::setPlacedBy(Level *level, int x, int y, int z, std::shared_p
 
 void DispenserTile::onRemove(Level *level, int x, int y, int z, int id, int data)
 {
-	std::shared_ptr<Container> container = dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) );
+	std::shared_ptr<Container> container = std::dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) );
 	if (container != NULL )
 	{
 		for (unsigned int i = 0; i < container->getContainerSize(); i++)
@@ -422,7 +422,7 @@ int DispenserTile::dispenseItem(std::shared_ptr<DispenserTileEntity> trap, Level
 			//MonsterPlacerItem *spawnEgg = (MonsterPlacerItem *)item->getItem();
 			std::shared_ptr<Entity> newEntity = MonsterPlacerItem::canSpawn(item->getAuxValue(), level,&iResult);
 			
-			std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(newEntity);
+			std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(newEntity);
 			if (mob != NULL)
 			{		
 				// 4J-PB - Changed the line below slightly since mobs were sticking to the dispenser rather than dropping down when fired
diff --git a/Minecraft.World/Blocks/EnderChestTile.cpp b/Minecraft.World/Blocks/EnderChestTile.cpp
index 764f706ac..993cc5803 100644
--- a/Minecraft.World/Blocks/EnderChestTile.cpp
+++ b/Minecraft.World/Blocks/EnderChestTile.cpp
@@ -64,7 +64,7 @@ void EnderChestTile::setPlacedBy(Level *level, int x, int y, int z, std::shared_
 bool EnderChestTile::use(Level *level, int x, int y, int z, std::shared_ptr<Player> player, int clickedFace, float clickX, float clickY, float clickZ, bool soundOnly)
 {
 	std::shared_ptr<PlayerEnderChestContainer> container = player->getEnderChestInventory();
-	std::shared_ptr<EnderChestTileEntity> enderChest = dynamic_pointer_cast<EnderChestTileEntity>(level->getTileEntity(x, y, z));
+	std::shared_ptr<EnderChestTileEntity> enderChest = std::dynamic_pointer_cast<EnderChestTileEntity>(level->getTileEntity(x, y, z));
 	if (container == NULL || enderChest == NULL) return true;
 
 	if (level->isSolidBlockingTile(x, y + 1, z)) return true;
diff --git a/Minecraft.World/Blocks/FarmTile.cpp b/Minecraft.World/Blocks/FarmTile.cpp
index 7f5ff4f66..b6a9c9ecc 100644
--- a/Minecraft.World/Blocks/FarmTile.cpp
+++ b/Minecraft.World/Blocks/FarmTile.cpp
@@ -81,7 +81,7 @@ void FarmTile::fallOn(Level *level, int x, int y, int z, std::shared_ptr<Entity>
 	if (!level->isClientSide && level->random->nextFloat() < (fallDistance - .5f))
 	{
 		// Fix for #60547 - TU7: Content: Gameplay: Players joining a game can destroy crops even with Trust Players option disabled.
-		std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(entity);
+		std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(entity);
 		if(player == NULL || player->isAllowedToMine()) level->setTile(x, y, z, Tile::dirt_Id);
     }
 }
diff --git a/Minecraft.World/Blocks/FurnaceTile.cpp b/Minecraft.World/Blocks/FurnaceTile.cpp
index 8e3cb2c66..7af0714c5 100644
--- a/Minecraft.World/Blocks/FurnaceTile.cpp
+++ b/Minecraft.World/Blocks/FurnaceTile.cpp
@@ -112,7 +112,7 @@ bool FurnaceTile::use(Level *level, int x, int y, int z, std::shared_ptr<Player>
 	{
 		return true;
 	}
-	std::shared_ptr<FurnaceTileEntity> furnace = dynamic_pointer_cast<FurnaceTileEntity>( level->getTileEntity(x, y, z) );
+	std::shared_ptr<FurnaceTileEntity> furnace = std::dynamic_pointer_cast<FurnaceTileEntity>( level->getTileEntity(x, y, z) );
 	if (furnace != NULL ) player->openFurnace(furnace);
 	return true;
 }
@@ -154,7 +154,7 @@ void FurnaceTile::onRemove(Level *level, int x, int y, int z, int id, int data)
 {
 	if (!noDrop)
 	{
-		std::shared_ptr<Container> container = dynamic_pointer_cast<FurnaceTileEntity>( level->getTileEntity(x, y, z) );
+		std::shared_ptr<Container> container = std::dynamic_pointer_cast<FurnaceTileEntity>( level->getTileEntity(x, y, z) );
 		if( container != NULL )
 		{
 			for (unsigned int i = 0; i < container->getContainerSize(); i++)
diff --git a/Minecraft.World/Blocks/MobSpawner.cpp b/Minecraft.World/Blocks/MobSpawner.cpp
index cff22088a..b85eca420 100644
--- a/Minecraft.World/Blocks/MobSpawner.cpp
+++ b/Minecraft.World/Blocks/MobSpawner.cpp
@@ -294,7 +294,7 @@ const int MobSpawner::tick(ServerLevel *level, bool spawnEnemies, bool spawnFrie
 //						   {
 	MemSect(29);
 							   //mob = type.mobClass.getConstructor(Level.class).newInstance(level);
-							   mob = dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(currentMobType->mobClass, level));
+							   mob = std::dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(currentMobType->mobClass, level));
 	MemSect(0);
 //						   }
 //						   catch (exception e)
@@ -425,18 +425,18 @@ bool MobSpawner::isSpawnPositionOk(MobCategory *category, Level *level, int x, i
 
 void MobSpawner::finalizeMobSettings(std::shared_ptr<Mob> mob, Level *level, float xx, float yy, float zz)
 {
-	if (dynamic_pointer_cast<Spider>( mob ) != NULL && level->random->nextInt(100) == 0)
+	if (std::dynamic_pointer_cast<Spider>( mob ) != NULL && level->random->nextInt(100) == 0)
 	{
 		std::shared_ptr<Skeleton> skeleton = std::shared_ptr<Skeleton>( new Skeleton(level) );
 		skeleton->moveTo(xx, yy, zz, mob->yRot, 0);
 		level->addEntity(skeleton);
 		skeleton->ride(mob);
 	}
-	else if (dynamic_pointer_cast<Sheep >( mob ) != NULL)
+	else if (std::dynamic_pointer_cast<Sheep >( mob ) != NULL)
 	{
-		(dynamic_pointer_cast<Sheep>( mob ))->setColor(Sheep::getSheepColor(level->random));
+		(std::dynamic_pointer_cast<Sheep>( mob ))->setColor(Sheep::getSheepColor(level->random));
 	}
-	else if (dynamic_pointer_cast<Ozelot >( mob ) != NULL)
+	else if (std::dynamic_pointer_cast<Ozelot >( mob ) != NULL)
 	{
 		if (level->random->nextInt(7) == 0)
 		{
@@ -520,7 +520,7 @@ bool MobSpawner::attackSleepingPlayers(Level *level, std::vector<std::shared_ptr
 //					{
 						//mob = classes[type].getConstructor(Level.class).newInstance(level);
 						// 4J - there was a classes array here which duplicated the bedEnemies array but have removed it
-						mob = dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(bedEnemies[type], level ));
+						mob = std::dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(bedEnemies[type], level ));
 //					}
 //					catch (exception e)
 //					{
@@ -621,7 +621,7 @@ void MobSpawner::postProcessSpawnMobs(Level *level, Biome *biome, int xo, int zo
 
 					std::shared_ptr<Mob> mob;
 					//try {
-					mob = dynamic_pointer_cast<Mob>( EntityIO::newByEnumType(type->mobClass, level ) );
+					mob = std::dynamic_pointer_cast<Mob>( EntityIO::newByEnumType(type->mobClass, level ) );
 					//} catch (Exception e) {
 					//	e.printStackTrace();
 					//	continue;
diff --git a/Minecraft.World/Blocks/MusicTile.cpp b/Minecraft.World/Blocks/MusicTile.cpp
index 6b51047f4..1a9712e77 100644
--- a/Minecraft.World/Blocks/MusicTile.cpp
+++ b/Minecraft.World/Blocks/MusicTile.cpp
@@ -12,7 +12,7 @@ void MusicTile::neighborChanged(Level *level, int x, int y, int z, int type)
 {
 	app.DebugPrintf("-------- Neighbour changed type %d\n", type);
 	bool signal = level->hasNeighborSignal(x, y, z);
-	std::shared_ptr<MusicTileEntity> mte = dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) );
+	std::shared_ptr<MusicTileEntity> mte = std::dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) );
 	app.DebugPrintf("-------- Signal is %s, tile is currently %s\n",signal?"TRUE":"FALSE", mte->on?"ON":"OFF");
 	if (mte != NULL && mte->on != signal)
 	{
@@ -34,7 +34,7 @@ bool MusicTile::use(Level *level, int x, int y, int z, std::shared_ptr<Player> p
 {
 	if (soundOnly) return false;
     if (level->isClientSide) return true;
-    std::shared_ptr<MusicTileEntity> mte = dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) );
+    std::shared_ptr<MusicTileEntity> mte = std::dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) );
 	if (mte != NULL )
 	{
 		mte->tune();
@@ -46,7 +46,7 @@ bool MusicTile::use(Level *level, int x, int y, int z, std::shared_ptr<Player> p
 void MusicTile::attack(Level *level, int x, int y, int z, std::shared_ptr<Player> player)
 {
     if (level->isClientSide) return;
-    std::shared_ptr<MusicTileEntity> mte = dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) );
+    std::shared_ptr<MusicTileEntity> mte = std::dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) );
     if( mte != NULL ) mte->playNote(level, x, y, z);
 }
 
diff --git a/Minecraft.World/Blocks/PistonBaseTile.cpp b/Minecraft.World/Blocks/PistonBaseTile.cpp
index 620a48be7..aaf67ea90 100644
--- a/Minecraft.World/Blocks/PistonBaseTile.cpp
+++ b/Minecraft.World/Blocks/PistonBaseTile.cpp
@@ -126,7 +126,7 @@ bool PistonBaseTile::use(Level *level, int x, int y, int z, std::shared_ptr<Play
 
 void PistonBaseTile::setPlacedBy(Level *level, int x, int y, int z, std::shared_ptr<Mob> by)
 {
-    int targetData = getNewFacing(level, x, y, z, dynamic_pointer_cast<Player>(by) );
+    int targetData = getNewFacing(level, x, y, z, std::dynamic_pointer_cast<Player>(by) );
     level->setData(x, y, z, targetData);
     if (!level->isClientSide && !ignoreUpdate())
 	{
@@ -250,9 +250,9 @@ void PistonBaseTile::triggerEvent(Level *level, int x, int y, int z, int param1,
 	{
 		PIXBeginNamedEvent(0,"Contract phase A\n");
         std::shared_ptr<TileEntity> prevTileEntity = level->getTileEntity(x + Facing::STEP_X[facing], y + Facing::STEP_Y[facing], z + Facing::STEP_Z[facing]);
-        if (prevTileEntity != NULL && dynamic_pointer_cast<PistonPieceEntity>(prevTileEntity) != NULL)
+        if (prevTileEntity != NULL && std::dynamic_pointer_cast<PistonPieceEntity>(prevTileEntity) != NULL)
 		{
-            dynamic_pointer_cast<PistonPieceEntity>(prevTileEntity)->finalTick();
+            std::dynamic_pointer_cast<PistonPieceEntity>(prevTileEntity)->finalTick();
         }
 
 		stopSharingIfServer(level, x, y, z);	// 4J added
@@ -281,9 +281,9 @@ void PistonBaseTile::triggerEvent(Level *level, int x, int y, int z, int param1,
                 // so replace it with the real data, since it's probably
                 // this piston which is changing too fast
                 std::shared_ptr<TileEntity> tileEntity = level->getTileEntity(twoX, twoY, twoZ);
-                if (tileEntity != NULL && dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL )
+                if (tileEntity != NULL && std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL )
 				{
-                    std::shared_ptr<PistonPieceEntity> ppe = dynamic_pointer_cast<PistonPieceEntity>(tileEntity);
+                    std::shared_ptr<PistonPieceEntity> ppe = std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity);
 
                     if (ppe->getFacing() == facing && ppe->isExtending())
 					{
diff --git a/Minecraft.World/Blocks/PistonMovingTileEntity.cpp b/Minecraft.World/Blocks/PistonMovingTileEntity.cpp
index 9fcd065c5..df22ca884 100644
--- a/Minecraft.World/Blocks/PistonMovingTileEntity.cpp
+++ b/Minecraft.World/Blocks/PistonMovingTileEntity.cpp
@@ -23,9 +23,9 @@ void PistonMovingPiece::onPlace(Level *level, int x, int y, int z)
 void PistonMovingPiece::onRemove(Level *level, int x, int y, int z, int id, int data)
 {
     std::shared_ptr<TileEntity> tileEntity = level->getTileEntity(x, y, z);
-    if (tileEntity != NULL && dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL)
+    if (tileEntity != NULL && std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL)
 	{
-        dynamic_pointer_cast<PistonPieceEntity>(tileEntity)->finalTick();
+        std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity)->finalTick();
     }
 	else
 	{
@@ -120,7 +120,7 @@ AABB *PistonMovingPiece::getAABB(Level *level, int x, int y, int z)
 
 void PistonMovingPiece::updateShape(LevelSource *level, int x, int y, int z, int forceData, std::shared_ptr<TileEntity> forceEntity) // 4J added forceData, forceEntity param
 {
-    std::shared_ptr<PistonPieceEntity> entity = dynamic_pointer_cast<PistonPieceEntity>(forceEntity);
+    std::shared_ptr<PistonPieceEntity> entity = std::dynamic_pointer_cast<PistonPieceEntity>(forceEntity);
 	if( entity == NULL ) entity = getEntity(level, x, y, z);
     if (entity != NULL)
 	{
@@ -191,9 +191,9 @@ AABB *PistonMovingPiece::getAABB(Level *level, int x, int y, int z, int tile, fl
 std::shared_ptr<PistonPieceEntity> PistonMovingPiece::getEntity(LevelSource *level, int x, int y, int z)
 {
     std::shared_ptr<TileEntity> tileEntity = level->getTileEntity(x, y, z);
-    if (tileEntity != NULL && dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL)
+    if (tileEntity != NULL && std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL)
 	{
-    	return  dynamic_pointer_cast<PistonPieceEntity>(tileEntity);
+    	return  std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity);
     }
     return nullptr;
 }
diff --git a/Minecraft.World/Blocks/RecordPlayerTile.cpp b/Minecraft.World/Blocks/RecordPlayerTile.cpp
index 274d541ed..cbf5cb4b1 100644
--- a/Minecraft.World/Blocks/RecordPlayerTile.cpp
+++ b/Minecraft.World/Blocks/RecordPlayerTile.cpp
@@ -42,7 +42,7 @@ void RecordPlayerTile::setRecord(Level *level, int x, int y, int z, int record)
 {
     if (level->isClientSide) return;
 
-    std::shared_ptr<RecordPlayerTile::Entity> rte = dynamic_pointer_cast<RecordPlayerTile::Entity>( level->getTileEntity(x, y, z) );
+    std::shared_ptr<RecordPlayerTile::Entity> rte = std::dynamic_pointer_cast<RecordPlayerTile::Entity>( level->getTileEntity(x, y, z) );
     rte->record = record;
     rte->setChanged();
 
@@ -53,7 +53,7 @@ void RecordPlayerTile::dropRecording(Level *level, int x, int y, int z)
 {
     if (level->isClientSide) return;
 
-    std::shared_ptr<RecordPlayerTile::Entity> rte = dynamic_pointer_cast<RecordPlayerTile::Entity>( level->getTileEntity(x, y, z) );
+    std::shared_ptr<RecordPlayerTile::Entity> rte = std::dynamic_pointer_cast<RecordPlayerTile::Entity>( level->getTileEntity(x, y, z) );
 	if( rte == NULL ) return;
 
     int oldRecord = rte->record;
diff --git a/Minecraft.World/Blocks/SignTile.cpp b/Minecraft.World/Blocks/SignTile.cpp
index 47d68eed1..63cf202e9 100644
--- a/Minecraft.World/Blocks/SignTile.cpp
+++ b/Minecraft.World/Blocks/SignTile.cpp
@@ -80,7 +80,7 @@ std::shared_ptr<TileEntity> SignTile::newTileEntity(Level *level)
 	//try {
 	// 4J Stu - For some reason the newInstance wasn't working right, but doing it like the other TileEntities is fine
 	return std::shared_ptr<TileEntity>( new SignTileEntity() );
-	//return dynamic_pointer_cast<TileEntity>( clas->newInstance() );
+	//return std::dynamic_pointer_cast<TileEntity>( clas->newInstance() );
 	//} catch (Exception e) {
 	// TODO 4J Stu - Exception handling
 	//    throw new RuntimeException(e);
diff --git a/Minecraft.World/Blocks/SkullTile.cpp b/Minecraft.World/Blocks/SkullTile.cpp
index 0f0a7e03a..9718cf954 100644
--- a/Minecraft.World/Blocks/SkullTile.cpp
+++ b/Minecraft.World/Blocks/SkullTile.cpp
@@ -75,7 +75,7 @@ int SkullTile::cloneTileId(Level *level, int x, int y, int z)
 int SkullTile::cloneTileData(Level *level, int x, int y, int z)
 {
 	std::shared_ptr<TileEntity> tileEntity = level->getTileEntity(x, y, z);
-	std::shared_ptr<SkullTileEntity> skull = dynamic_pointer_cast<SkullTileEntity>(tileEntity);
+	std::shared_ptr<SkullTileEntity> skull = std::dynamic_pointer_cast<SkullTileEntity>(tileEntity);
 	if (skull != NULL)
 	{
 		return skull->getSkullType();
@@ -117,7 +117,7 @@ void SkullTile::onRemove(Level *level, int x, int y, int z)//, int id, int data)
 	if ((data & NO_DROP_BIT) == 0)
 	{
 		std::shared_ptr<ItemInstance> item = std::shared_ptr<ItemInstance>(new ItemInstance(Item::skull_Id, 1, cloneTileData(level, x, y, z)));
-		std::shared_ptr<SkullTileEntity> entity = dynamic_pointer_cast<SkullTileEntity>(level->getTileEntity(x, y, z));
+		std::shared_ptr<SkullTileEntity> entity = std::dynamic_pointer_cast<SkullTileEntity>(level->getTileEntity(x, y, z));
 
 		if (entity->getSkullType() == SkullTileEntity::TYPE_CHAR && !entity->getExtraType().empty())
 		{
@@ -245,7 +245,7 @@ bool SkullTile::isSkullAt(Level *level, int x, int y, int z, int skullType)
 		return false;
 	}
 	std::shared_ptr<TileEntity> te = level->getTileEntity(x, y, z);
-	std::shared_ptr<SkullTileEntity> skull = dynamic_pointer_cast<SkullTileEntity>(te);
+	std::shared_ptr<SkullTileEntity> skull = std::dynamic_pointer_cast<SkullTileEntity>(te);
 	if (skull == NULL)
 	{
 		return false;
diff --git a/Minecraft.World/Blocks/TheEndPortalTile.cpp b/Minecraft.World/Blocks/TheEndPortalTile.cpp
index 7be05366c..9a978099f 100644
--- a/Minecraft.World/Blocks/TheEndPortalTile.cpp
+++ b/Minecraft.World/Blocks/TheEndPortalTile.cpp
@@ -66,7 +66,7 @@ void TheEndPortal::entityInside(Level *level, int x, int y, int z, std::shared_p
 {
     if (entity->riding == NULL && entity->rider.lock() == NULL)
 	{
-        if (dynamic_pointer_cast<Player>(entity) != NULL)
+        if (std::dynamic_pointer_cast<Player>(entity) != NULL)
 		{
             if (!level->isClientSide)
 			{
@@ -80,7 +80,7 @@ void TheEndPortal::entityInside(Level *level, int x, int y, int z, std::shared_p
 					level->getLevelData()->setHasStrongholdEndPortal();
 				}
 
-                (dynamic_pointer_cast<Player>(entity))->changeDimension(1);
+                (std::dynamic_pointer_cast<Player>(entity))->changeDimension(1);
             }
         }
     }
diff --git a/Minecraft.World/Blocks/TileEntities/ChestTileEntity.cpp b/Minecraft.World/Blocks/TileEntities/ChestTileEntity.cpp
index 1608971f5..46264b17b 100644
--- a/Minecraft.World/Blocks/TileEntities/ChestTileEntity.cpp
+++ b/Minecraft.World/Blocks/TileEntities/ChestTileEntity.cpp
@@ -165,19 +165,19 @@ void ChestTileEntity::checkNeighbors()
 
     if (level->getTile(x - 1, y, z) == Tile::chest_Id)
 	{
-        w = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x - 1, y, z));
+        w = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x - 1, y, z));
     }
     if (level->getTile(x + 1, y, z) == Tile::chest_Id)
 	{
-        e = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x + 1, y, z));
+        e = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x + 1, y, z));
     }
     if (level->getTile(x, y, z - 1) == Tile::chest_Id)
 	{
-        n = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z - 1));
+        n = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z - 1));
     }
     if (level->getTile(x, y, z + 1) == Tile::chest_Id)
 	{
-        s = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z + 1));
+        s = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z + 1));
     }
 
     if (n.lock() != NULL) n.lock()->clearCache();
diff --git a/Minecraft.World/Blocks/TileEntities/MobSpawnerTileEntity.cpp b/Minecraft.World/Blocks/TileEntities/MobSpawnerTileEntity.cpp
index 27b0d21c5..3b7093237 100644
--- a/Minecraft.World/Blocks/TileEntities/MobSpawnerTileEntity.cpp
+++ b/Minecraft.World/Blocks/TileEntities/MobSpawnerTileEntity.cpp
@@ -89,7 +89,7 @@ void MobSpawnerTileEntity::tick()
 
 		for (int c = 0; c < spawnCount; c++) 
 		{
-			std::shared_ptr<Mob> entity = dynamic_pointer_cast<Mob> (EntityIO::newEntity(entityId, level));
+			std::shared_ptr<Mob> entity = std::dynamic_pointer_cast<Mob> (EntityIO::newEntity(entityId, level));
 			if (entity == NULL) return;
 
 			std::vector<std::shared_ptr<Entity> > *vecNearby = level->getEntitiesOfClass(typeid(*entity), AABB::newTemp(x, y, z, x + 1, y + 1, z + 1)->grow(8, 4, 8));
@@ -115,7 +115,7 @@ void MobSpawnerTileEntity::tick()
 				double xp = x + (level->random->nextDouble() - level->random->nextDouble()) * 4;
 				double yp = y + level->random->nextInt(3) - 1;
 				double zp = z + (level->random->nextDouble() - level->random->nextDouble()) * 4;
-				std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>( entity );
+				std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>( entity );
 
 				entity->moveTo(xp, yp, zp, level->random->nextFloat() * 360, 0);
 
diff --git a/Minecraft.World/Blocks/TntTile.cpp b/Minecraft.World/Blocks/TntTile.cpp
index cf6f107a0..041221cbc 100644
--- a/Minecraft.World/Blocks/TntTile.cpp
+++ b/Minecraft.World/Blocks/TntTile.cpp
@@ -98,7 +98,7 @@ void TntTile::entityInside(Level *level, int x, int y, int z, std::shared_ptr<En
 	if (entity->GetType() == eTYPE_ARROW && !level->isClientSide)
 	{
 		// 4J Stu - Don't need to cast this
-		//std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(entity);
+		//std::shared_ptr<Arrow> arrow = std::dynamic_pointer_cast<Arrow>(entity);
 		if (entity->isOnFire())
 		{
 			destroy(level, x, y, z, EXPLODE_BIT);
diff --git a/Minecraft.World/Blocks/TreeTile.cpp b/Minecraft.World/Blocks/TreeTile.cpp
index 682fcd974..b8e9fa5ba 100644
--- a/Minecraft.World/Blocks/TreeTile.cpp
+++ b/Minecraft.World/Blocks/TreeTile.cpp
@@ -63,7 +63,7 @@ void TreeTile::onRemove(Level *level, int x, int y, int z, int id, int data)
 void TreeTile::setPlacedBy(Level *level, int x, int y, int z, std::shared_ptr<Mob> by)
 {
 	int type = level->getData(x, y, z) & MASK_TYPE;
-	int dir = PistonBaseTile::getNewFacing(level, x, y, z, dynamic_pointer_cast<Player>(by));
+	int dir = PistonBaseTile::getNewFacing(level, x, y, z, std::dynamic_pointer_cast<Player>(by));
 	int facing = 0;
 
 	switch (dir)
diff --git a/Minecraft.World/Blocks/WaterLilyTile.cpp b/Minecraft.World/Blocks/WaterLilyTile.cpp
index 32497630f..0453986b2 100644
--- a/Minecraft.World/Blocks/WaterLilyTile.cpp
+++ b/Minecraft.World/Blocks/WaterLilyTile.cpp
@@ -25,7 +25,7 @@ int WaterlilyTile::getRenderShape()
 
 void WaterlilyTile::addAABBs(Level *level, int x, int y, int z, AABB *box, AABBList *boxes, std::shared_ptr<Entity> source)
 {
-	if (source == NULL || !(dynamic_pointer_cast<Boat>(source)))
+	if (source == NULL || !(std::dynamic_pointer_cast<Boat>(source)))
 	{
 		Bush::addAABBs(level, x, y, z, box, boxes, source);
 	}
diff --git a/Minecraft.World/Commands/KillCommand.cpp b/Minecraft.World/Commands/KillCommand.cpp
index e41bb6df6..13790f284 100644
--- a/Minecraft.World/Commands/KillCommand.cpp
+++ b/Minecraft.World/Commands/KillCommand.cpp
@@ -11,7 +11,7 @@ EGameCommand KillCommand::getId()
 
 void KillCommand::execute(std::shared_ptr<CommandSender> source, byteArray commandData)
 {
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(source);
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(source);
 
 	player->hurt(DamageSource::outOfWorld, 1000);
 
diff --git a/Minecraft.World/Containers/BrewingStandMenu.cpp b/Minecraft.World/Containers/BrewingStandMenu.cpp
index ee40737b2..5fce45ac9 100644
--- a/Minecraft.World/Containers/BrewingStandMenu.cpp
+++ b/Minecraft.World/Containers/BrewingStandMenu.cpp
@@ -12,9 +12,9 @@ BrewingStandMenu::BrewingStandMenu(std::shared_ptr<Inventory> inventory, std::sh
 
 	this->brewingStand = brewingStand;
 
-	addSlot(new PotionSlot(dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 0, 56, 46));
-	addSlot(new PotionSlot(dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 1, 79, 53));
-	addSlot(new PotionSlot(dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 2, 102, 46));
+	addSlot(new PotionSlot(std::dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 0, 56, 46));
+	addSlot(new PotionSlot(std::dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 1, 79, 53));
+	addSlot(new PotionSlot(std::dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 2, 102, 46));
 	ingredientSlot = addSlot(new IngredientsSlot(brewingStand, 3, 79, 17));
 
 	for (int y = 0; y < 3; y++)
@@ -190,7 +190,7 @@ int BrewingStandMenu::PotionSlot::getMaxStackSize()
 
 void BrewingStandMenu::PotionSlot::onTake(std::shared_ptr<Player> player, std::shared_ptr<ItemInstance> carried)
 {
-	carried->onCraftedBy(this->player->level, dynamic_pointer_cast<Player>( this->player->shared_from_this() ), 1);
+	carried->onCraftedBy(this->player->level, std::dynamic_pointer_cast<Player>( this->player->shared_from_this() ), 1);
 	if (carried->id == Item::potion_Id && carried->getAuxValue() > 0)
 		this->player->awardStat(GenericStats::potion(),GenericStats::param_potion());
 	Slot::onTake(player, carried);
diff --git a/Minecraft.World/Containers/ContainerMenu.cpp b/Minecraft.World/Containers/ContainerMenu.cpp
index a07046ce9..393b26b4b 100644
--- a/Minecraft.World/Containers/ContainerMenu.cpp
+++ b/Minecraft.World/Containers/ContainerMenu.cpp
@@ -90,7 +90,7 @@ std::shared_ptr<ItemInstance> ContainerMenu::clicked(int slotIndex, int buttonNu
 	std::shared_ptr<ItemInstance> out = AbstractContainerMenu::clicked(slotIndex, buttonNum, clickType, player);
 
 #ifdef _EXTENDED_ACHIEVEMENTS
-	std::shared_ptr<LocalPlayer> localPlayer = dynamic_pointer_cast<LocalPlayer>(player);
+	std::shared_ptr<LocalPlayer> localPlayer = std::dynamic_pointer_cast<LocalPlayer>(player);
 
 	if (localPlayer != NULL)	// 4J-JEV: For "Chestful o'Cobblestone" achievement.
 	{
diff --git a/Minecraft.World/Containers/FurnaceMenu.cpp b/Minecraft.World/Containers/FurnaceMenu.cpp
index e70e32721..494d78f99 100644
--- a/Minecraft.World/Containers/FurnaceMenu.cpp
+++ b/Minecraft.World/Containers/FurnaceMenu.cpp
@@ -18,7 +18,7 @@ FurnaceMenu::FurnaceMenu(std::shared_ptr<Inventory> inventory, std::shared_ptr<F
 
 	addSlot(new Slot(furnace, 0, 52 + 4, 13 + 4));
 	addSlot(new Slot(furnace, 1, 52 + 4, 49 + 4));
-	addSlot(new FurnaceResultSlot( dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), furnace, 2, 112 + 4, 31 + 4));
+	addSlot(new FurnaceResultSlot( std::dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), furnace, 2, 112 + 4, 31 + 4));
 
 	for (int y = 0; y < 3; y++)
 	{
diff --git a/Minecraft.World/Containers/Inventory.cpp b/Minecraft.World/Containers/Inventory.cpp
index 93afbb2c5..4f69f43a6 100644
--- a/Minecraft.World/Containers/Inventory.cpp
+++ b/Minecraft.World/Containers/Inventory.cpp
@@ -606,7 +606,7 @@ void Inventory::hurtArmor(int dmg)
 	{
 		if (armor[i] != NULL && dynamic_cast<ArmorItem *>( armor[i]->getItem() ) != NULL )
 		{
-			armor[i]->hurt(dmg, dynamic_pointer_cast<Mob>( player->shared_from_this() ) );
+			armor[i]->hurt(dmg, std::dynamic_pointer_cast<Mob>( player->shared_from_this() ) );
 			if (armor[i]->count == 0)
 			{
 				armor[i] = nullptr;
diff --git a/Minecraft.World/Containers/MerchantMenu.cpp b/Minecraft.World/Containers/MerchantMenu.cpp
index 28f062bfc..618353eb4 100644
--- a/Minecraft.World/Containers/MerchantMenu.cpp
+++ b/Minecraft.World/Containers/MerchantMenu.cpp
@@ -10,7 +10,7 @@ MerchantMenu::MerchantMenu(std::shared_ptr<Inventory> inventory, std::shared_ptr
 	trader = merchant;
 	this->level = level;
 
-	tradeContainer = std::shared_ptr<MerchantContainer>( new MerchantContainer(dynamic_pointer_cast<Player>(inventory->player->shared_from_this()), merchant) );
+	tradeContainer = std::shared_ptr<MerchantContainer>( new MerchantContainer(std::dynamic_pointer_cast<Player>(inventory->player->shared_from_this()), merchant) );
 	addSlot(new Slot(tradeContainer, PAYMENT1_SLOT, SELLSLOT1_X, ROW2_Y));
 	addSlot(new Slot(tradeContainer, PAYMENT2_SLOT, SELLSLOT2_X, ROW2_Y));
 	addSlot(new MerchantResultSlot(inventory->player, merchant, tradeContainer, RESULT_SLOT, BUYSLOT_X, ROW2_Y));
diff --git a/Minecraft.World/Containers/MerchantResultSlot.cpp b/Minecraft.World/Containers/MerchantResultSlot.cpp
index 0a1d08aeb..919d451ce 100644
--- a/Minecraft.World/Containers/MerchantResultSlot.cpp
+++ b/Minecraft.World/Containers/MerchantResultSlot.cpp
@@ -33,7 +33,7 @@ void MerchantResultSlot::onQuickCraft(std::shared_ptr<ItemInstance> picked, int
 
 void MerchantResultSlot::checkTakeAchievements(std::shared_ptr<ItemInstance> carried)
 {
-	carried->onCraftedBy(player->level, dynamic_pointer_cast<Player>(player->shared_from_this()), removeCount);
+	carried->onCraftedBy(player->level, std::dynamic_pointer_cast<Player>(player->shared_from_this()), removeCount);
 	removeCount = 0;
 }
 
diff --git a/Minecraft.World/Containers/ResultSlot.cpp b/Minecraft.World/Containers/ResultSlot.cpp
index 40696e333..25d333b96 100644
--- a/Minecraft.World/Containers/ResultSlot.cpp
+++ b/Minecraft.World/Containers/ResultSlot.cpp
@@ -35,7 +35,7 @@ void ResultSlot::onQuickCraft(std::shared_ptr<ItemInstance> picked, int count)
 
 void ResultSlot::checkTakeAchievements(std::shared_ptr<ItemInstance> carried)
 {
-	carried->onCraftedBy(player->level, dynamic_pointer_cast<Player>( player->shared_from_this() ), removeCount);
+	carried->onCraftedBy(player->level, std::dynamic_pointer_cast<Player>( player->shared_from_this() ), removeCount);
 	removeCount = 0;
 
 	if (carried->id == Tile::workBench_Id)				player->awardStat(GenericStats::buildWorkbench(),		GenericStats::param_buildWorkbench());
diff --git a/Minecraft.World/Entities/BossMobPart.cpp b/Minecraft.World/Entities/BossMobPart.cpp
index a6750f601..e602f3443 100644
--- a/Minecraft.World/Entities/BossMobPart.cpp
+++ b/Minecraft.World/Entities/BossMobPart.cpp
@@ -34,7 +34,7 @@ bool BossMobPart::isPickable()
 
 bool BossMobPart::hurt(DamageSource *source, int damage)
 {
-	return bossMob->hurt( dynamic_pointer_cast<BossMobPart>( shared_from_this() ), source, damage);
+	return bossMob->hurt( std::dynamic_pointer_cast<BossMobPart>( shared_from_this() ), source, damage);
 }
 
 bool BossMobPart::is(std::shared_ptr<Entity> other)
diff --git a/Minecraft.World/Entities/Entity.cpp b/Minecraft.World/Entities/Entity.cpp
index de30141a5..1d4cddb7c 100644
--- a/Minecraft.World/Entities/Entity.cpp
+++ b/Minecraft.World/Entities/Entity.cpp
@@ -675,7 +675,7 @@ void Entity::move(double xa, double ya, double za, bool noEntityCubes)   // 4J -
 
 	AABB *bbOrg = bb->copy();
 
-	bool isPlayerSneaking = onGround && isSneaking() && dynamic_pointer_cast<Player>(shared_from_this()) != NULL;
+	bool isPlayerSneaking = onGround && isSneaking() && std::dynamic_pointer_cast<Player>(shared_from_this()) != NULL;
 
 	if (isPlayerSneaking)
 	{
@@ -1006,7 +1006,7 @@ void Entity::checkFallDamage(double ya, bool onGround)
 	{
 		if (fallDistance > 0)
 		{
-			if (dynamic_pointer_cast<Mob>(shared_from_this()) != NULL)
+			if (std::dynamic_pointer_cast<Mob>(shared_from_this()) != NULL)
 			{
 				int xt = Mth::floor(x);
 				int yt = Mth::floor(y - 0.2f - this->heightOffset);
@@ -1539,7 +1539,7 @@ void Entity::positionRider()
 	std::shared_ptr<Entity> lockedRider = rider.lock();
 	if( lockedRider )
 	{
-		std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(lockedRider);
+		std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(lockedRider);
 		if (!(player && player->isLocalPlayer()))
 		{
 			lockedRider->xOld = xOld;
diff --git a/Minecraft.World/Entities/EntityDamageSource.cpp b/Minecraft.World/Entities/EntityDamageSource.cpp
index 918c8a371..9f87e6ce9 100644
--- a/Minecraft.World/Entities/EntityDamageSource.cpp
+++ b/Minecraft.World/Entities/EntityDamageSource.cpp
@@ -26,7 +26,7 @@ std::shared_ptr<ChatPacket> EntityDamageSource::getDeathMessagePacket(std::share
 	std::wstring additional = L"";
 	if(entity->GetType() == eTYPE_SERVERPLAYER)
 	{
-		std::shared_ptr<Player> sourcePlayer = dynamic_pointer_cast<Player>(entity);
+		std::shared_ptr<Player> sourcePlayer = std::dynamic_pointer_cast<Player>(entity);
 		if(sourcePlayer != NULL) additional = sourcePlayer->name;
 	}
 	return std::shared_ptr<ChatPacket>( new ChatPacket(player->name, m_msgId, entity->GetType(), additional ) );
@@ -34,5 +34,5 @@ std::shared_ptr<ChatPacket> EntityDamageSource::getDeathMessagePacket(std::share
 
 bool EntityDamageSource::scalesWithDifficulty()
 {
-	return entity != NULL && dynamic_pointer_cast<Mob>(entity) && !(dynamic_pointer_cast<Player>(entity));
+	return entity != NULL && std::dynamic_pointer_cast<Mob>(entity) && !(std::dynamic_pointer_cast<Player>(entity));
 }
\ No newline at end of file
diff --git a/Minecraft.World/Entities/HangingEntity.cpp b/Minecraft.World/Entities/HangingEntity.cpp
index a996c756f..c3976e843 100644
--- a/Minecraft.World/Entities/HangingEntity.cpp
+++ b/Minecraft.World/Entities/HangingEntity.cpp
@@ -156,7 +156,7 @@ bool HangingEntity::survives()
 				for (AUTO_VAR(it, entities->begin()); it != itEnd; it++)
 				{
 					std::shared_ptr<Entity> e = (*it);
-					if(dynamic_pointer_cast<HangingEntity>(e) != NULL)
+					if(std::dynamic_pointer_cast<HangingEntity>(e) != NULL)
 					{
 						return false;
 					}
@@ -176,7 +176,7 @@ bool HangingEntity::skipAttackInteraction(std::shared_ptr<Entity> source)
 {
 	if(source->GetType()==eTYPE_PLAYER)
 	{
-		return hurt(DamageSource::playerAttack(dynamic_pointer_cast<Player>( source)), 0);
+		return hurt(DamageSource::playerAttack(std::dynamic_pointer_cast<Player>( source)), 0);
 	}
 	return false;
 }
@@ -189,7 +189,7 @@ bool HangingEntity::hurt(DamageSource *source, int damage)
 		{
 			std::shared_ptr<Entity> sourceEntity = source->getDirectEntity();
 
-			if (dynamic_pointer_cast<Player>(sourceEntity) != NULL && !dynamic_pointer_cast<Player>(sourceEntity)->isAllowedToHurtEntity(shared_from_this()) )
+			if (std::dynamic_pointer_cast<Player>(sourceEntity) != NULL && !std::dynamic_pointer_cast<Player>(sourceEntity)->isAllowedToHurtEntity(shared_from_this()) )
 			{
 				return false;
 			}
@@ -202,7 +202,7 @@ bool HangingEntity::hurt(DamageSource *source, int damage)
 		std::shared_ptr<Entity> e = source->getEntity();
 		if (e!=NULL && ((e->GetType() & eTYPE_PLAYER)!=0) ) // check if it's serverplayer or player
 		{
-			player = dynamic_pointer_cast<Player>( e );
+			player = std::dynamic_pointer_cast<Player>( e );
 		}
 
 		if (player != NULL && player->abilities.instabuild) 
diff --git a/Minecraft.World/Entities/IndirectEntityDamageSource.cpp b/Minecraft.World/Entities/IndirectEntityDamageSource.cpp
index 7f43e0331..fc197c099 100644
--- a/Minecraft.World/Entities/IndirectEntityDamageSource.cpp
+++ b/Minecraft.World/Entities/IndirectEntityDamageSource.cpp
@@ -36,7 +36,7 @@ std::shared_ptr<ChatPacket> IndirectEntityDamageSource::getDeathMessagePacket(st
 		type = owner->GetType();
 		if(type == eTYPE_SERVERPLAYER)
 		{
-			std::shared_ptr<Player> sourcePlayer = dynamic_pointer_cast<Player>(owner);
+			std::shared_ptr<Player> sourcePlayer = std::dynamic_pointer_cast<Player>(owner);
 			if(sourcePlayer != NULL) additional = sourcePlayer->name;
 		}
 	}
diff --git a/Minecraft.World/Entities/ItemEntity.cpp b/Minecraft.World/Entities/ItemEntity.cpp
index 7a5a03d74..cb2650c9a 100644
--- a/Minecraft.World/Entities/ItemEntity.cpp
+++ b/Minecraft.World/Entities/ItemEntity.cpp
@@ -137,7 +137,7 @@ void ItemEntity::mergeWithNeighbours()
 	std::vector<std::shared_ptr<Entity> > *neighbours = level->getEntitiesOfClass(typeid(*this), bb->grow(0.5, 0, 0.5));
 	for(AUTO_VAR(it, neighbours->begin()); it != neighbours->end(); ++it)
 	{
-		std::shared_ptr<ItemEntity> entity = dynamic_pointer_cast<ItemEntity>(*it);
+		std::shared_ptr<ItemEntity> entity = std::dynamic_pointer_cast<ItemEntity>(*it);
 		merge(entity);
 	}
 	delete neighbours;
@@ -154,7 +154,7 @@ bool ItemEntity::merge(std::shared_ptr<ItemEntity> target)
 	if (targetItem->hasTag() ^ myItem->hasTag()) return false;
 	if (targetItem->hasTag() && !targetItem->getTag()->equals(myItem->getTag())) return false;
 	if (targetItem->getItem()->isStackedByData() && targetItem->getAuxValue() != myItem->getAuxValue()) return false;
-	if (targetItem->count < myItem->count) return target->merge(dynamic_pointer_cast<ItemEntity>(shared_from_this()));
+	if (targetItem->count < myItem->count) return target->merge(std::dynamic_pointer_cast<ItemEntity>(shared_from_this()));
 	if (targetItem->count + myItem->count > targetItem->getMaxStackSize()) return false;
 
 	targetItem->count += myItem->count;
diff --git a/Minecraft.World/Entities/Mob.cpp b/Minecraft.World/Entities/Mob.cpp
index cefd8405b..fe4446495 100644
--- a/Minecraft.World/Entities/Mob.cpp
+++ b/Minecraft.World/Entities/Mob.cpp
@@ -205,7 +205,7 @@ std::shared_ptr<Mob> Mob::getLastHurtMob()
 
 void Mob::setLastHurtMob(std::shared_ptr<Entity> target)
 {
-	std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(target);
+	std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(target);
 	if (mob != NULL) lastHurtMob = mob;
 }
 
@@ -661,7 +661,7 @@ bool Mob::hurt(DamageSource *source, int dmg)
 	if ( source->isFire() && hasEffect(MobEffect::fireResistance) )
 	{
 		// 4J-JEV, for new achievement Stayin'Frosty, TODO merge with Java version.
-		std::shared_ptr<Player> plr = dynamic_pointer_cast<Player>(shared_from_this());
+		std::shared_ptr<Player> plr = std::dynamic_pointer_cast<Player>(shared_from_this());
 		if ( plr != NULL && source == DamageSource::lava ) // Only award when in lava (not any fire).
 		{
 			plr->awardStat(GenericStats::stayinFrosty(),GenericStats::param_stayinFrosty());
@@ -693,18 +693,18 @@ bool Mob::hurt(DamageSource *source, int dmg)
 	std::shared_ptr<Entity> sourceEntity = source->getEntity();
 	if (sourceEntity != NULL)
 	{
-		if (dynamic_pointer_cast<Mob>(sourceEntity) != NULL) {
-			setLastHurtByMob(dynamic_pointer_cast<Mob>(sourceEntity));
+		if (std::dynamic_pointer_cast<Mob>(sourceEntity) != NULL) {
+			setLastHurtByMob(std::dynamic_pointer_cast<Mob>(sourceEntity));
 
 		}
-		if (dynamic_pointer_cast<Player>(sourceEntity) != NULL)
+		if (std::dynamic_pointer_cast<Player>(sourceEntity) != NULL)
 		{
 			lastHurtByPlayerTime = PLAYER_HURT_EXPERIENCE_TIME;
-			lastHurtByPlayer = dynamic_pointer_cast<Player>(sourceEntity);
+			lastHurtByPlayer = std::dynamic_pointer_cast<Player>(sourceEntity);
 		}
-		else if (dynamic_pointer_cast<Wolf>(sourceEntity))
+		else if (std::dynamic_pointer_cast<Wolf>(sourceEntity))
 		{
-			std::shared_ptr<Wolf> w = dynamic_pointer_cast<Wolf>(sourceEntity);
+			std::shared_ptr<Wolf> w = std::dynamic_pointer_cast<Wolf>(sourceEntity);
 			if (w->isTame())
 			{
 				lastHurtByPlayerTime = PLAYER_HURT_EXPERIENCE_TIME;
@@ -856,14 +856,14 @@ void Mob::die(DamageSource *source)
 	std::shared_ptr<Entity> sourceEntity = source->getEntity();
 	if (deathScore >= 0 && sourceEntity != NULL) sourceEntity->awardKillScore(shared_from_this(), deathScore);
 
-	if (sourceEntity != NULL) sourceEntity->killed( dynamic_pointer_cast<Mob>( shared_from_this() ) );
+	if (sourceEntity != NULL) sourceEntity->killed( std::dynamic_pointer_cast<Mob>( shared_from_this() ) );
 
 	dead = true;
 
 	if (!level->isClientSide) 
 	{
 		int playerBonus = 0;
-		std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(sourceEntity);
+		std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(sourceEntity);
 		if (player != NULL)
 		{
 			playerBonus = EnchantmentHelper::getKillingLootBonus(player->inventory);
@@ -884,7 +884,7 @@ void Mob::die(DamageSource *source)
 		// 4J-JEV, hook for Durango mobKill event.
 		if (player != NULL)
 		{
-			player->awardStat(GenericStats::killMob(),GenericStats::param_mobKill(player, dynamic_pointer_cast<Mob>(shared_from_this()), source));
+			player->awardStat(GenericStats::killMob(),GenericStats::param_mobKill(player, std::dynamic_pointer_cast<Mob>(shared_from_this()), source));
 		}
 	}
 
@@ -953,14 +953,14 @@ void Mob::causeFallDamage(float distance)
 void Mob::travel(float xa, float ya) 
 {
 #ifdef __PSVITA__
-	// AP - dynamic_pointer_cast is a non-trivial call
+	// AP - std::dynamic_pointer_cast is a non-trivial call
 	Player *thisPlayer = NULL;
 	if( (GetType() & eTYPE_PLAYER) == eTYPE_PLAYER )
 	{
 		thisPlayer = (Player*) this;
 	}
 #else
-	std::shared_ptr<Player> thisPlayer = dynamic_pointer_cast<Player>(shared_from_this());
+	std::shared_ptr<Player> thisPlayer = std::dynamic_pointer_cast<Player>(shared_from_this());
 #endif
 	if (isInWater() && !(thisPlayer && thisPlayer->abilities.flying) ) 
 	{
@@ -1038,7 +1038,7 @@ void Mob::travel(float xa, float ya)
 			if (zd > max) zd = max;
 			this->fallDistance = 0;
 			if (yd < -0.15) yd = -0.15;
-			bool playerSneaking = isSneaking() && dynamic_pointer_cast<Player>(shared_from_this()) != NULL;
+			bool playerSneaking = isSneaking() && std::dynamic_pointer_cast<Player>(shared_from_this()) != NULL;
 			if (playerSneaking && yd < 0) yd = 0;
 		}
 
@@ -1455,7 +1455,7 @@ void Mob::lookAt(std::shared_ptr<Entity> e, float yMax, float xMax)
 	double yd;
 	double zd = e->z - z;
 	
-	std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e);
+	std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(e);
 	if(mob != NULL)
 	{
 		yd = (y + getHeadHeight()) - (mob->y + mob->getHeadHeight());
@@ -1657,7 +1657,7 @@ void Mob::tickEffects()
 	{
 		MobEffectInstance *effect = it->second;
 		removed = false;
-		if (!effect->tick(dynamic_pointer_cast<Mob>(shared_from_this())))
+		if (!effect->tick(std::dynamic_pointer_cast<Mob>(shared_from_this())))
 		{
 			if (!level->isClientSide)
 			{
diff --git a/Minecraft.World/Entities/MobEffect.cpp b/Minecraft.World/Entities/MobEffect.cpp
index 270e4f799..5b8100217 100644
--- a/Minecraft.World/Entities/MobEffect.cpp
+++ b/Minecraft.World/Entities/MobEffect.cpp
@@ -104,11 +104,11 @@ void MobEffect::applyEffectTick(std::shared_ptr<Mob> mob, int amplification)
 			mob->hurt(DamageSource::magic, 1);
 		}
 	}
-	else if (id == hunger->id && dynamic_pointer_cast<Player>(mob) != NULL)
+	else if (id == hunger->id && std::dynamic_pointer_cast<Player>(mob) != NULL)
 	{
 		// every tick, cause the same amount of exhaustion as when removing
 		// a block, times amplification
-		dynamic_pointer_cast<Player>(mob)->causeFoodExhaustion(FoodConstants::EXHAUSTION_MINE * (amplification + 1));
+		std::dynamic_pointer_cast<Player>(mob)->causeFoodExhaustion(FoodConstants::EXHAUSTION_MINE * (amplification + 1));
 	}
 	else if ((id == heal->id && !mob->isInvertedHealAndHarm()) || (id == harm->id && mob->isInvertedHealAndHarm()))
 	{
diff --git a/Minecraft.World/Entities/Mobs/AgeableMob.cpp b/Minecraft.World/Entities/Mobs/AgeableMob.cpp
index af2cb19be..6a95405b3 100644
--- a/Minecraft.World/Entities/Mobs/AgeableMob.cpp
+++ b/Minecraft.World/Entities/Mobs/AgeableMob.cpp
@@ -24,7 +24,7 @@ bool AgableMob::interact(std::shared_ptr<Player> player)
 			eINSTANCEOF classToSpawn = EntityIO::getClass(item->getAuxValue());
 			if (classToSpawn != eTYPE_NOTSET && (classToSpawn & eTYPE_AGABLE_MOB) == eTYPE_AGABLE_MOB && classToSpawn == GetType() ) // 4J Added GetType() check to only spawn same type
 			{
-				std::shared_ptr<AgableMob> offspring = getBreedOffspring(dynamic_pointer_cast<AgableMob>(shared_from_this()));
+				std::shared_ptr<AgableMob> offspring = getBreedOffspring(std::dynamic_pointer_cast<AgableMob>(shared_from_this()));
 				if (offspring != NULL)
 				{
 					offspring->setAge(-20 * 60 * 20);
diff --git a/Minecraft.World/Entities/Mobs/Animal.cpp b/Minecraft.World/Entities/Mobs/Animal.cpp
index b4994463c..16676bd56 100644
--- a/Minecraft.World/Entities/Mobs/Animal.cpp
+++ b/Minecraft.World/Entities/Mobs/Animal.cpp
@@ -62,7 +62,7 @@ void Animal::aiStep()
 
 void Animal::checkHurtTarget(std::shared_ptr<Entity> target, float d)
 {
-	if (dynamic_pointer_cast<Player>(target) != NULL)
+	if (std::dynamic_pointer_cast<Player>(target) != NULL)
 	{
 		if (d < 3)
 		{
@@ -73,7 +73,7 @@ void Animal::checkHurtTarget(std::shared_ptr<Entity> target, float d)
 			holdGround = true;
 		}
 
-		std::shared_ptr<Player> p = dynamic_pointer_cast<Player>(target);
+		std::shared_ptr<Player> p = std::dynamic_pointer_cast<Player>(target);
 		if (p->getSelectedItem() != NULL && this->isFood(p->getSelectedItem()))
 		{
 		}
@@ -83,9 +83,9 @@ void Animal::checkHurtTarget(std::shared_ptr<Entity> target, float d)
 		}
 
 	}
-	else if (dynamic_pointer_cast<Animal>(target) != NULL)
+	else if (std::dynamic_pointer_cast<Animal>(target) != NULL)
 	{
-		std::shared_ptr<Animal> a = dynamic_pointer_cast<Animal>(target);
+		std::shared_ptr<Animal> a = std::dynamic_pointer_cast<Animal>(target);
 		if (getAge() > 0 && a->getAge() < 0)
 		{
 			if (d < 2.5)
@@ -170,15 +170,15 @@ bool Animal::hurt(DamageSource *dmgSource, int dmg)
 	{
 		std::shared_ptr<Entity> source = dmgSource->getDirectEntity();
 
-		if (dynamic_pointer_cast<Player>(source) != NULL &&	!dynamic_pointer_cast<Player>(source)->isAllowedToAttackAnimals() )
+		if (std::dynamic_pointer_cast<Player>(source) != NULL &&	!std::dynamic_pointer_cast<Player>(source)->isAllowedToAttackAnimals() )
 		{
 			return false;
 		}
 
 		if (source != NULL && source->GetType() == eTYPE_ARROW)
 		{
-			std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(source);
-			if (dynamic_pointer_cast<Player>(arrow->owner) != NULL && ! dynamic_pointer_cast<Player>(arrow->owner)->isAllowedToAttackAnimals() )
+			std::shared_ptr<Arrow> arrow = std::dynamic_pointer_cast<Arrow>(source);
+			if (std::dynamic_pointer_cast<Player>(arrow->owner) != NULL && ! std::dynamic_pointer_cast<Player>(arrow->owner)->isAllowedToAttackAnimals() )
 			{
 				return false;
 			}
@@ -216,7 +216,7 @@ std::shared_ptr<Entity> Animal::findAttackTarget()
 		//for (int i = 0; i < others->size(); i++)
 		for(AUTO_VAR(it, others->begin()); it != others->end(); ++it)
 		{
-			std::shared_ptr<Animal> p = dynamic_pointer_cast<Animal>(*it);
+			std::shared_ptr<Animal> p = std::dynamic_pointer_cast<Animal>(*it);
 			if (p != shared_from_this() && p->getInLoveValue() > 0)
 			{
 				delete others;
@@ -235,7 +235,7 @@ std::shared_ptr<Entity> Animal::findAttackTarget()
 			{
 				setDespawnProtected();
 
-				std::shared_ptr<Player> p = dynamic_pointer_cast<Player>(*it);
+				std::shared_ptr<Player> p = std::dynamic_pointer_cast<Player>(*it);
 				if (p->getSelectedItem() != NULL && this->isFood(p->getSelectedItem()))
 				{
 					delete players;
@@ -250,7 +250,7 @@ std::shared_ptr<Entity> Animal::findAttackTarget()
 			//for (int i = 0; i < others.size(); i++)			
 			for(AUTO_VAR(it, others->begin()); it != others->end(); ++it)
 			{
-				std::shared_ptr<Animal> p = dynamic_pointer_cast<Animal>(*it);
+				std::shared_ptr<Animal> p = std::dynamic_pointer_cast<Animal>(*it);
 				if (p != shared_from_this() && p->getAge() < 0)
 				{
 					delete others;
diff --git a/Minecraft.World/Entities/Mobs/Arrow.cpp b/Minecraft.World/Entities/Mobs/Arrow.cpp
index edf27dd0f..2eec5e9ce 100644
--- a/Minecraft.World/Entities/Mobs/Arrow.cpp
+++ b/Minecraft.World/Entities/Mobs/Arrow.cpp
@@ -57,7 +57,7 @@ Arrow::Arrow(Level *level, std::shared_ptr<Mob> mob, std::shared_ptr<Mob> target
 	_init();
 
 	this->owner = mob;
-	if ( dynamic_pointer_cast<Player>( mob ) != NULL) pickup = PICKUP_ALLOWED;
+	if ( std::dynamic_pointer_cast<Player>( mob ) != NULL) pickup = PICKUP_ALLOWED;
 
 	y = mob->y + mob->getHeadHeight() - 0.1f;
 
@@ -94,7 +94,7 @@ Arrow::Arrow(Level *level, std::shared_ptr<Mob> mob, float power) : Entity( leve
 	_init();
 
 	this->owner = mob;
-	if ( dynamic_pointer_cast<Player>( mob ) != NULL) pickup = PICKUP_ALLOWED;
+	if ( std::dynamic_pointer_cast<Player>( mob ) != NULL) pickup = PICKUP_ALLOWED;
 
 	setSize(0.5f, 0.5f);
 
@@ -281,11 +281,11 @@ void Arrow::tick()
 			DamageSource *damageSource = NULL;
 			if (owner == NULL)
 			{
-				damageSource = DamageSource::arrow(dynamic_pointer_cast<Arrow>(shared_from_this()), shared_from_this());
+				damageSource = DamageSource::arrow(std::dynamic_pointer_cast<Arrow>(shared_from_this()), shared_from_this());
 			}
 			else
 			{
-				damageSource = DamageSource::arrow(dynamic_pointer_cast<Arrow>(shared_from_this()), owner);
+				damageSource = DamageSource::arrow(std::dynamic_pointer_cast<Arrow>(shared_from_this()), owner);
 			}
 
 			if(res->entity->hurt(damageSource, dmg))
@@ -299,7 +299,7 @@ void Arrow::tick()
 					res->entity->setOnFire(5);
 				}
 
-				std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(res->entity);
+				std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(res->entity);
 				if (mob != NULL)
 				{
 					mob->arrowCount++;
@@ -319,12 +319,12 @@ void Arrow::tick()
 				}
 
 				// 4J : WESTY : For award, need to track if creeper was killed by arrow from the player.
-				if ( (dynamic_pointer_cast<Player>(owner) != NULL ) &&				// arrow owner is a player
+				if ( (std::dynamic_pointer_cast<Player>(owner) != NULL ) &&				// arrow owner is a player
 					( res->entity->isAlive() == false ) &&							// target is now dead
-					( dynamic_pointer_cast<Creeper>( res->entity ) != NULL ) )		// target is a creeper
+					( std::dynamic_pointer_cast<Creeper>( res->entity ) != NULL ) )		// target is a creeper
 
 				{
-					dynamic_pointer_cast<Player>(owner)->awardStat(
+					std::dynamic_pointer_cast<Player>(owner)->awardStat(
 						GenericStats::arrowKillCreeper(),
 						GenericStats::param_arrowKillCreeper()
 						);
diff --git a/Minecraft.World/Entities/Mobs/Blaze.cpp b/Minecraft.World/Entities/Mobs/Blaze.cpp
index 20b1a164e..bbdf674c3 100644
--- a/Minecraft.World/Entities/Mobs/Blaze.cpp
+++ b/Minecraft.World/Entities/Mobs/Blaze.cpp
@@ -154,7 +154,7 @@ void Blaze::checkHurtTarget(std::shared_ptr<Entity> target, float d)
 				level->levelEvent(nullptr, LevelEvent::SOUND_BLAZE_FIREBALL, (int) x, (int) y, (int) z, 0);
 				//                    level.playSound(this, "mob.ghast.fireball", getSoundVolume(), (random.nextFloat() - random.nextFloat()) * 0.2f + 1.0f);
 				for (int i = 0; i < 1; i++) {
-					std::shared_ptr<SmallFireball> ie = std::shared_ptr<SmallFireball>( new SmallFireball(level, dynamic_pointer_cast<Mob>( shared_from_this() ), xd + random->nextGaussian() * sqd, yd, zd + random->nextGaussian() * sqd) );
+					std::shared_ptr<SmallFireball> ie = std::shared_ptr<SmallFireball>( new SmallFireball(level, std::dynamic_pointer_cast<Mob>( shared_from_this() ), xd + random->nextGaussian() * sqd, yd, zd + random->nextGaussian() * sqd) );
 					//                        Vec3 v = getViewVector(1);
 					//                        ie.x = x + v.x * 1.5;
 					ie->y = y + bbHeight / 2 + 0.5f;
diff --git a/Minecraft.World/Entities/Mobs/Boat.cpp b/Minecraft.World/Entities/Mobs/Boat.cpp
index e1da9d062..08e96f950 100644
--- a/Minecraft.World/Entities/Mobs/Boat.cpp
+++ b/Minecraft.World/Entities/Mobs/Boat.cpp
@@ -100,8 +100,8 @@ bool Boat::hurt(DamageSource *source, int hurtDamage)
 	{
 		std::shared_ptr<Entity> attacker = source->getDirectEntity();
 
-		if (dynamic_pointer_cast<Player>(attacker) != NULL && 
-			!dynamic_pointer_cast<Player>(attacker)->isAllowedToHurtEntity( shared_from_this() ))
+		if (std::dynamic_pointer_cast<Player>(attacker) != NULL && 
+			!std::dynamic_pointer_cast<Player>(attacker)->isAllowedToHurtEntity( shared_from_this() ))
 			return false;
 	}
 
@@ -117,7 +117,7 @@ bool Boat::hurt(DamageSource *source, int hurtDamage)
 	markHurt();
 
 	// 4J Stu - Brought froward from 12w36 to fix #46611 - TU5: Gameplay: Minecarts and boat requires more hits than one to be destroyed in creative mode
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(source->getEntity());
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(source->getEntity());
 	if (player != NULL && player->abilities.instabuild) setDamage(100);
 
 	if (getDamage() > 20 * 2)
@@ -469,7 +469,7 @@ std::wstring Boat::getName()
 
 bool Boat::interact(std::shared_ptr<Player> player)
 {
-	if (rider.lock() != NULL && dynamic_pointer_cast<Player>(rider.lock())!=NULL && rider.lock() != player) return true;
+	if (rider.lock() != NULL && std::dynamic_pointer_cast<Player>(rider.lock())!=NULL && rider.lock() != player) return true;
 	if (!level->isClientSide)
 	{
 		// 4J HEG - Fixed issue with player not being able to dismount boat (issue #4446)
diff --git a/Minecraft.World/Entities/Mobs/CaveSpider.cpp b/Minecraft.World/Entities/Mobs/CaveSpider.cpp
index a0caaea26..a48454cc0 100644
--- a/Minecraft.World/Entities/Mobs/CaveSpider.cpp
+++ b/Minecraft.World/Entities/Mobs/CaveSpider.cpp
@@ -32,7 +32,7 @@ bool CaveSpider::doHurtTarget(std::shared_ptr<Entity> target)
 {
 	if (Spider::doHurtTarget(target))
 	{
-		if ( dynamic_pointer_cast<Mob>(target) != NULL)
+		if ( std::dynamic_pointer_cast<Mob>(target) != NULL)
 		{
 			int poisonTime = 0;
 			if (level->difficulty <= Difficulty::EASY)
@@ -49,7 +49,7 @@ bool CaveSpider::doHurtTarget(std::shared_ptr<Entity> target)
 			}
 
 			if (poisonTime > 0) {
-				dynamic_pointer_cast<Mob>(target)->addEffect(new MobEffectInstance(MobEffect::poison->id, poisonTime * SharedConstants::TICKS_PER_SECOND, 0));
+				std::dynamic_pointer_cast<Mob>(target)->addEffect(new MobEffectInstance(MobEffect::poison->id, poisonTime * SharedConstants::TICKS_PER_SECOND, 0));
 			}
 		}
 
diff --git a/Minecraft.World/Entities/Mobs/Creeper.cpp b/Minecraft.World/Entities/Mobs/Creeper.cpp
index 0a9c948eb..2d9ab3108 100644
--- a/Minecraft.World/Entities/Mobs/Creeper.cpp
+++ b/Minecraft.World/Entities/Mobs/Creeper.cpp
@@ -120,13 +120,13 @@ void Creeper::die(DamageSource *source)
 {
     Monster::die(source);
 
-    if ( dynamic_pointer_cast<Skeleton>(source->getEntity()) != NULL )
+    if ( std::dynamic_pointer_cast<Skeleton>(source->getEntity()) != NULL )
 	{
         spawnAtLocation(Item::record_01_Id + random->nextInt(12), 1);
     }
 
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(source->getEntity());
-	if ( (dynamic_pointer_cast<Arrow>(source->getDirectEntity()) != NULL) && (player != NULL) )
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(source->getEntity());
+	if ( (std::dynamic_pointer_cast<Arrow>(source->getDirectEntity()) != NULL) && (player != NULL) )
 	{
 		player->awardStat(GenericStats::archer(), GenericStats::param_archer());
 	}
diff --git a/Minecraft.World/Entities/Mobs/DragonFireball.cpp b/Minecraft.World/Entities/Mobs/DragonFireball.cpp
index f22eb748c..70f57ad3d 100644
--- a/Minecraft.World/Entities/Mobs/DragonFireball.cpp
+++ b/Minecraft.World/Entities/Mobs/DragonFireball.cpp
@@ -40,7 +40,7 @@ void DragonFireball::onHit(HitResult *res)
 			for( AUTO_VAR(it, entitiesOfClass->begin()); it != entitiesOfClass->end(); ++it)
 			{
 				//std::shared_ptr<Entity> e = *it;
-				std::shared_ptr<Mob> e = dynamic_pointer_cast<Mob>( *it );
+				std::shared_ptr<Mob> e = std::dynamic_pointer_cast<Mob>( *it );
 				double dist = distanceToSqr(e);
 				if (dist < SPLASH_RANGE_SQ)
 				{
diff --git a/Minecraft.World/Entities/Mobs/EnderCrystal.cpp b/Minecraft.World/Entities/Mobs/EnderCrystal.cpp
index 3a262c63a..2e2d54426 100644
--- a/Minecraft.World/Entities/Mobs/EnderCrystal.cpp
+++ b/Minecraft.World/Entities/Mobs/EnderCrystal.cpp
@@ -91,7 +91,7 @@ bool EnderCrystal::isPickable()
 bool EnderCrystal::hurt(DamageSource *source, int damage)
 {
 	// 4J-PB - if the owner of the source is the enderdragon, then ignore it (where the dragon's fireball hits an endercrystal)
-	std::shared_ptr<EnderDragon> sourceIsDragon = dynamic_pointer_cast<EnderDragon>(source->getEntity());
+	std::shared_ptr<EnderDragon> sourceIsDragon = std::dynamic_pointer_cast<EnderDragon>(source->getEntity());
 
 	if(sourceIsDragon!=NULL)
 	{
@@ -114,7 +114,7 @@ bool EnderCrystal::hurt(DamageSource *source, int damage)
 				for (AUTO_VAR(it, entities.begin()); it != itEnd; it++)
 				{
 					std::shared_ptr<Entity> e = *it; //entities->at(i);
-					dragon = dynamic_pointer_cast<EnderDragon>(e);
+					dragon = std::dynamic_pointer_cast<EnderDragon>(e);
 					if(dragon != NULL)
 					{
 						dragon->handleCrystalDestroyed(source);
diff --git a/Minecraft.World/Entities/Mobs/EnderDragon.cpp b/Minecraft.World/Entities/Mobs/EnderDragon.cpp
index 99a11462c..7edb77cdb 100644
--- a/Minecraft.World/Entities/Mobs/EnderDragon.cpp
+++ b/Minecraft.World/Entities/Mobs/EnderDragon.cpp
@@ -444,7 +444,7 @@ void EnderDragon::aiStep()
 
 				for( AUTO_VAR(it, targets->begin() ); it != targets->end(); ++it)
 				{
-					std::shared_ptr<Mob> e = dynamic_pointer_cast<Mob>( *it );
+					std::shared_ptr<Mob> e = std::dynamic_pointer_cast<Mob>( *it );
 					if (e != NULL)
 					{
 						//app.DebugPrintf("Attacking entity with acid\n");
@@ -734,7 +734,7 @@ void EnderDragon::aiStep()
 					double zdd = attackTarget->z - startingZ;
 
 					level->levelEvent(nullptr, LevelEvent::SOUND_GHAST_FIREBALL, (int) x, (int) y, (int) z, 0);
-					std::shared_ptr<DragonFireball> ie = std::shared_ptr<DragonFireball>( new DragonFireball(level, dynamic_pointer_cast<Mob>( shared_from_this() ), xdd, ydd, zdd) );
+					std::shared_ptr<DragonFireball> ie = std::shared_ptr<DragonFireball>( new DragonFireball(level, std::dynamic_pointer_cast<Mob>( shared_from_this() ), xdd, ydd, zdd) );
 					ie->x = startingX;
 					ie->y = startingY;
 					ie->z = startingZ;
@@ -800,7 +800,7 @@ void EnderDragon::checkCrystals()
 		//for (Entity ec : crystals)
  		for(AUTO_VAR(it, crystals->begin()); it != crystals->end(); ++it)
 		{
-			std::shared_ptr<EnderCrystal> ec = dynamic_pointer_cast<EnderCrystal>( *it );
+			std::shared_ptr<EnderCrystal> ec = std::dynamic_pointer_cast<EnderCrystal>( *it );
 			double dist = ec->distanceToSqr(shared_from_this() );
 			if (dist < nearest)
 			{
@@ -840,7 +840,7 @@ void EnderDragon::knockBack(std::vector<std::shared_ptr<Entity> > *entities)
 	//for (Entity e : entities)
 	for(AUTO_VAR(it, entities->begin()); it != entities->end(); ++it)
 	{
-		std::shared_ptr<Mob> e = dynamic_pointer_cast<Mob>( *it );
+		std::shared_ptr<Mob> e = std::dynamic_pointer_cast<Mob>( *it );
 		if (e != NULL)//(e instanceof Mob)
 		{
 			double xd = e->x - xm;
@@ -856,10 +856,10 @@ void EnderDragon::hurt(std::vector<std::shared_ptr<Entity> > *entities)
 	//for (int i = 0; i < entities->size(); i++)
 	for(AUTO_VAR(it, entities->begin()); it != entities->end(); ++it)
 	{
-		std::shared_ptr<Mob> e = dynamic_pointer_cast<Mob>( *it );//entities.get(i);
+		std::shared_ptr<Mob> e = std::dynamic_pointer_cast<Mob>( *it );//entities.get(i);
 		if (e != NULL) //(e instanceof Mob)
 		{
-			DamageSource *damageSource = DamageSource::mobAttack( dynamic_pointer_cast<Mob>( shared_from_this() ));
+			DamageSource *damageSource = DamageSource::mobAttack( std::dynamic_pointer_cast<Mob>( shared_from_this() ));
 			e->hurt(damageSource, 10);
 			delete damageSource;
 		}
@@ -1116,7 +1116,7 @@ bool EnderDragon::hurt(std::shared_ptr<BossMobPart> bossMobPart, DamageSource *s
 	//zTarget = z - cc1 * 5 + (random->nextFloat() - 0.5f) * 2;
 	//attackTarget = NULL;
 
-	if (source == DamageSource::explosion || (dynamic_pointer_cast<Player>(source->getEntity()) != NULL))
+	if (source == DamageSource::explosion || (std::dynamic_pointer_cast<Player>(source->getEntity()) != NULL))
 	{
 		int healthBefore = health;
 		reallyHurt(source, damage);
@@ -1461,11 +1461,11 @@ void EnderDragon::handleCrystalDestroyed(DamageSource *source)
 #endif
 		}
 	}
-	else if(dynamic_pointer_cast<Player>(source->getEntity()) != NULL)
+	else if(std::dynamic_pointer_cast<Player>(source->getEntity()) != NULL)
 	{
 		if(setSynchedAction(e_EnderdragonAction_StrafePlayer))
 		{
-			attackTarget = dynamic_pointer_cast<Player>(source->getEntity());
+			attackTarget = std::dynamic_pointer_cast<Player>(source->getEntity());
 #if PRINT_DRAGON_STATE_CHANGE_MESSAGES
 			app.DebugPrintf("Dragon action is now: StrafePlayer\n");
 #endif
diff --git a/Minecraft.World/Entities/Mobs/EnderMan.cpp b/Minecraft.World/Entities/Mobs/EnderMan.cpp
index da5ae5c69..6c3ab9528 100644
--- a/Minecraft.World/Entities/Mobs/EnderMan.cpp
+++ b/Minecraft.World/Entities/Mobs/EnderMan.cpp
@@ -210,7 +210,7 @@ void EnderMan::aiStep()
 	{
 		if (attackTarget != NULL)
 		{
-			if ( dynamic_pointer_cast<Player>(attackTarget) != NULL && isLookingAtMe(dynamic_pointer_cast<Player>(attackTarget)))
+			if ( std::dynamic_pointer_cast<Player>(attackTarget) != NULL && isLookingAtMe(std::dynamic_pointer_cast<Player>(attackTarget)))
 			{
 				xxa = yya = 0;
 				runSpeed = 0;
diff --git a/Minecraft.World/Entities/Mobs/Fireball.cpp b/Minecraft.World/Entities/Mobs/Fireball.cpp
index 7d9df934a..27e8d25bb 100644
--- a/Minecraft.World/Entities/Mobs/Fireball.cpp
+++ b/Minecraft.World/Entities/Mobs/Fireball.cpp
@@ -298,7 +298,7 @@ void Fireball::onHit(HitResult *res)
 	{
 		if (res->entity != NULL)
 		{
-			DamageSource *damageSource = DamageSource::fireball(dynamic_pointer_cast<Fireball>( shared_from_this() ), owner);
+			DamageSource *damageSource = DamageSource::fireball(std::dynamic_pointer_cast<Fireball>( shared_from_this() ), owner);
 			if (res->entity->hurt(damageSource, 6))
 			{
 			}
@@ -374,7 +374,7 @@ bool Fireball::hurt(DamageSource *source, int damage)
             yPower = yd * 0.1;
             zPower = zd * 0.1;
         }
-		std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>( source->getEntity() );
+		std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>( source->getEntity() );
 		if (mob != NULL)
 		{
 			owner = mob;
diff --git a/Minecraft.World/Entities/Mobs/FishingHook.cpp b/Minecraft.World/Entities/Mobs/FishingHook.cpp
index cfa6d2bc1..c7402da16 100644
--- a/Minecraft.World/Entities/Mobs/FishingHook.cpp
+++ b/Minecraft.World/Entities/Mobs/FishingHook.cpp
@@ -58,7 +58,7 @@ FishingHook::FishingHook(Level *level, double x, double y, double z, std::shared
 
 	this->owner = owner;
 	// 4J Stu - Moved this outside the ctor
-	//owner->fishing = dynamic_pointer_cast<FishingHook>( shared_from_this() );
+	//owner->fishing = std::dynamic_pointer_cast<FishingHook>( shared_from_this() );
 
 	setPos(x, y, z);
 }
@@ -69,7 +69,7 @@ FishingHook::FishingHook(Level *level, std::shared_ptr<Player> mob) : Entity( le
 
 	this->owner = mob;
 	// 4J Stu - Moved this outside the ctor
-	//owner->fishing = dynamic_pointer_cast<FishingHook>( shared_from_this() );
+	//owner->fishing = std::dynamic_pointer_cast<FishingHook>( shared_from_this() );
 
 	this->moveTo(mob->x, mob->y + 1.62 - mob->heightOffset, mob->z, mob->yRot, mob->xRot);
 
@@ -265,7 +265,7 @@ void FishingHook::tick()
 		if (res->entity != NULL) 
 		{
 			// 4J Stu Move fix for : fix for #48587 - CRASH: Code: Gameplay: Hitting another player with the fishing bobber crashes the game. [Fishing pole, line]
-			// Incorrect dynamic_pointer_cast used around the shared_from_this()
+			// Incorrect std::dynamic_pointer_cast used around the shared_from_this()
 			DamageSource *damageSource = DamageSource::thrown(shared_from_this(), owner);
 			if (res->entity->hurt(damageSource, 0))
 			{
diff --git a/Minecraft.World/Entities/Mobs/Ghast.cpp b/Minecraft.World/Entities/Mobs/Ghast.cpp
index ca4893ce5..06a4bdb3c 100644
--- a/Minecraft.World/Entities/Mobs/Ghast.cpp
+++ b/Minecraft.World/Entities/Mobs/Ghast.cpp
@@ -49,7 +49,7 @@ bool Ghast::hurt(DamageSource *source, int dmg)
 {
 	if (source->getMsgId() == ChatPacket::e_ChatDeathFireball)
 	{
-		std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( source->getEntity() );
+		std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( source->getEntity() );
 		if (player != NULL)
 		{
 			// reflected fireball, kill the ghast
@@ -151,7 +151,7 @@ void Ghast::serverAiStep()
 			{
 				// 4J - change brought forward from 1.2.3
 				level->levelEvent(nullptr, LevelEvent::SOUND_GHAST_FIREBALL, (int) x, (int) y, (int) z, 0);
-                std::shared_ptr<Fireball> ie = std::shared_ptr<Fireball>( new Fireball(level, dynamic_pointer_cast<Mob>( shared_from_this() ), xdd, ydd, zdd) );
+                std::shared_ptr<Fireball> ie = std::shared_ptr<Fireball>( new Fireball(level, std::dynamic_pointer_cast<Mob>( shared_from_this() ), xdd, ydd, zdd) );
                 double d = 4;
                 Vec3 *v = getViewVector(1);
                 ie->x = x + v->x * d;
diff --git a/Minecraft.World/Entities/Mobs/ItemFrame.cpp b/Minecraft.World/Entities/Mobs/ItemFrame.cpp
index 13bf5f37b..a5b44491b 100644
--- a/Minecraft.World/Entities/Mobs/ItemFrame.cpp
+++ b/Minecraft.World/Entities/Mobs/ItemFrame.cpp
@@ -66,7 +66,7 @@ void ItemFrame::setItem(std::shared_ptr<ItemInstance> item)
 		item = item->copy();
 		item->count = 1;
 
-		item->setFramed(dynamic_pointer_cast<ItemFrame>( shared_from_this() ));
+		item->setFramed(std::dynamic_pointer_cast<ItemFrame>( shared_from_this() ));
 	}
 	getEntityData()->set(DATA_ITEM, item);
 	getEntityData()->markDirty(DATA_ITEM);
diff --git a/Minecraft.World/Entities/Mobs/Minecart.cpp b/Minecraft.World/Entities/Mobs/Minecart.cpp
index c48e98d72..ae3386fda 100644
--- a/Minecraft.World/Entities/Mobs/Minecart.cpp
+++ b/Minecraft.World/Entities/Mobs/Minecart.cpp
@@ -185,8 +185,8 @@ bool Minecart::hurt(DamageSource *source, int hurtDamage)
 	{
 		std::shared_ptr<Entity> attacker = source->getDirectEntity();
 
-		if (dynamic_pointer_cast<Player>(attacker) != NULL && 
-			!dynamic_pointer_cast<Player>(attacker)->isAllowedToHurtEntity( shared_from_this() ))
+		if (std::dynamic_pointer_cast<Player>(attacker) != NULL && 
+			!std::dynamic_pointer_cast<Player>(attacker)->isAllowedToHurtEntity( shared_from_this() ))
 			return false;
 	}
 
@@ -200,7 +200,7 @@ bool Minecart::hurt(DamageSource *source, int hurtDamage)
 	if( rider.lock() != NULL && rider.lock() == source->getEntity() ) hurtDamage += 1;
 
 	// 4J Stu - Brought froward from 12w36 to fix #46611 - TU5: Gameplay: Minecarts and boat requires more hits than one to be destroyed in creative mode
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(source->getEntity());
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(source->getEntity());
 	if (player != NULL && player->abilities.instabuild) this->setDamage(100);
 
 	this->setDamage(getDamage() + (hurtDamage * 10));
@@ -213,7 +213,7 @@ bool Minecart::hurt(DamageSource *source, int hurtDamage)
 		spawnAtLocation(Item::minecart->id, 1, 0);
 		if (type == Minecart::CHEST)
 		{
-			std::shared_ptr<Container> container = dynamic_pointer_cast<Container>( shared_from_this() );
+			std::shared_ptr<Container> container = std::dynamic_pointer_cast<Container>( shared_from_this() );
 			for (unsigned int i = 0; i < container->getContainerSize(); i++)
 			{
 				std::shared_ptr<ItemInstance> item = container->getItem(i);
@@ -676,7 +676,7 @@ void Minecart::tick()
 					std::shared_ptr<Entity> e = (*it); //entities->at(i);
 					if (e != rider.lock() && e->isPushable() && e->GetType() == eTYPE_MINECART)
 					{
-						std::shared_ptr<Minecart> cart = dynamic_pointer_cast<Minecart>(e);
+						std::shared_ptr<Minecart> cart = std::dynamic_pointer_cast<Minecart>(e);
 						cart->m_bHasPushedCartThisTick = false;
 						cart->push(shared_from_this());
 
@@ -903,7 +903,7 @@ void Minecart::push(std::shared_ptr<Entity> e)
 	if (level->isClientSide) return;
 
 	if (e == rider.lock()) return;
-	if (( dynamic_pointer_cast<Mob>(e)!=NULL) && dynamic_pointer_cast<Player>(e)==NULL && dynamic_pointer_cast<VillagerGolem>(e) == NULL && type == Minecart::RIDEABLE && xd * xd + zd * zd > 0.01)
+	if (( std::dynamic_pointer_cast<Mob>(e)!=NULL) && std::dynamic_pointer_cast<Player>(e)==NULL && std::dynamic_pointer_cast<VillagerGolem>(e) == NULL && type == Minecart::RIDEABLE && xd * xd + zd * zd > 0.01)
 	{
 		if (rider.lock() == NULL && e->riding == NULL)
 		{
@@ -952,7 +952,7 @@ void Minecart::push(std::shared_ptr<Entity> e)
 			double xdd = (e->xd + xd);
 			double zdd = (e->zd + zd);
 
-			std::shared_ptr<Minecart> cart = dynamic_pointer_cast<Minecart>(e);
+			std::shared_ptr<Minecart> cart = std::dynamic_pointer_cast<Minecart>(e);
 			if (cart != NULL && cart->type == Minecart::FURNACE && type != Minecart::FURNACE)
 			{
 				xd *= 0.2f;
@@ -1075,7 +1075,7 @@ bool Minecart::interact(std::shared_ptr<Player> player)
 {
 	if (type == Minecart::RIDEABLE)
 	{
-		if (rider.lock() != NULL && dynamic_pointer_cast<Player>(rider.lock())!=NULL && rider.lock() != player) return true;
+		if (rider.lock() != NULL && std::dynamic_pointer_cast<Player>(rider.lock())!=NULL && rider.lock() != player) return true;
 		if (!level->isClientSide)
 		{
 			// 4J HEG - Fixed issue with player not being able to dismount minecart (issue #4455)
@@ -1087,7 +1087,7 @@ bool Minecart::interact(std::shared_ptr<Player> player)
 		if ( player->isAllowedToInteract(shared_from_this()) )
 		{
 			if (!level->isClientSide)
-				player->openContainer( dynamic_pointer_cast<Container>( shared_from_this() ) );
+				player->openContainer( std::dynamic_pointer_cast<Container>( shared_from_this() ) );
 		}
 		else
 		{
diff --git a/Minecraft.World/Entities/Mobs/Ocelot.cpp b/Minecraft.World/Entities/Mobs/Ocelot.cpp
index 2243299e9..95bb3121a 100644
--- a/Minecraft.World/Entities/Mobs/Ocelot.cpp
+++ b/Minecraft.World/Entities/Mobs/Ocelot.cpp
@@ -186,7 +186,7 @@ int Ozelot::getDeathLoot()
 
 bool Ozelot::doHurtTarget(std::shared_ptr<Entity> target)
 {
-	return target->hurt(DamageSource::mobAttack(dynamic_pointer_cast<Mob>(shared_from_this())), 3);
+	return target->hurt(DamageSource::mobAttack(std::dynamic_pointer_cast<Mob>(shared_from_this())), 3);
 }
 
 bool Ozelot::hurt(DamageSource *source, int dmg)
@@ -280,7 +280,7 @@ bool Ozelot::canMate(std::shared_ptr<Animal> animal)
 	if (animal == shared_from_this()) return false;
 	if (!isTame()) return false;
 
-	std::shared_ptr<Ozelot> partner = dynamic_pointer_cast<Ozelot>(animal);
+	std::shared_ptr<Ozelot> partner = std::dynamic_pointer_cast<Ozelot>(animal);
 	if (partner == NULL) return false;
 	if (!partner->isTame()) return false;
 
diff --git a/Minecraft.World/Entities/Mobs/Pig.cpp b/Minecraft.World/Entities/Mobs/Pig.cpp
index de8a2f599..52fb0e21a 100644
--- a/Minecraft.World/Entities/Mobs/Pig.cpp
+++ b/Minecraft.World/Entities/Mobs/Pig.cpp
@@ -56,7 +56,7 @@ int Pig::getMaxHealth()
 
 bool Pig::canBeControlledByRider()
 {
-	std::shared_ptr<ItemInstance> item = dynamic_pointer_cast<Player>(rider.lock())->getCarriedItem();
+	std::shared_ptr<ItemInstance> item = std::dynamic_pointer_cast<Player>(rider.lock())->getCarriedItem();
 
 	return item != NULL && item->id == Item::carrotOnAStick_Id;
 }
@@ -162,9 +162,9 @@ void Pig::thunderHit(const LightningBolt *lightningBolt)
 void Pig::causeFallDamage(float distance) 
 {
 	Animal::causeFallDamage(distance);
-	if (distance > 5 && dynamic_pointer_cast<Player>( rider.lock() ) != NULL)
+	if (distance > 5 && std::dynamic_pointer_cast<Player>( rider.lock() ) != NULL)
 	{
-		(dynamic_pointer_cast<Player>(rider.lock()))->awardStat(GenericStats::flyPig(),GenericStats::param_flyPig());
+		(std::dynamic_pointer_cast<Player>(rider.lock()))->awardStat(GenericStats::flyPig(),GenericStats::param_flyPig());
 	}
 }
 
diff --git a/Minecraft.World/Entities/Mobs/PigZombie.cpp b/Minecraft.World/Entities/Mobs/PigZombie.cpp
index 1e689a052..028d65d4e 100644
--- a/Minecraft.World/Entities/Mobs/PigZombie.cpp
+++ b/Minecraft.World/Entities/Mobs/PigZombie.cpp
@@ -104,16 +104,16 @@ std::shared_ptr<Entity> PigZombie::findAttackTarget()
 bool PigZombie::hurt(DamageSource *source, int dmg)
 {
 	std::shared_ptr<Entity> sourceEntity = source->getEntity();
-    if (dynamic_pointer_cast<Player>(sourceEntity) != NULL)
+    if (std::dynamic_pointer_cast<Player>(sourceEntity) != NULL)
 	{
         std::vector<std::shared_ptr<Entity> > *nearby = level->getEntities( shared_from_this(), bb->grow(32, 32, 32));		
 		AUTO_VAR(itEnd, nearby->end());
 		for (AUTO_VAR(it, nearby->begin()); it != itEnd; it++)
 		{
             std::shared_ptr<Entity> e = *it; //nearby->at(i);
-            if (dynamic_pointer_cast<PigZombie>(e) != NULL)
+            if (std::dynamic_pointer_cast<PigZombie>(e) != NULL)
 			{
-                std::shared_ptr<PigZombie> pigZombie = dynamic_pointer_cast<PigZombie>(e);
+                std::shared_ptr<PigZombie> pigZombie = std::dynamic_pointer_cast<PigZombie>(e);
                 pigZombie->alert(sourceEntity);
             }
         }
diff --git a/Minecraft.World/Entities/Mobs/Sheep.cpp b/Minecraft.World/Entities/Mobs/Sheep.cpp
index 9b75c0b80..d852eeb6e 100644
--- a/Minecraft.World/Entities/Mobs/Sheep.cpp
+++ b/Minecraft.World/Entities/Mobs/Sheep.cpp
@@ -277,9 +277,9 @@ std::shared_ptr<AgableMob> Sheep::getBreedOffspring(std::shared_ptr<AgableMob> t
 	// 4J - added limit to number of animals that can be bred
 	if( level->canCreateMore( GetType(), Level::eSpawnType_Breed) )
 	{
-		std::shared_ptr<Sheep> otherSheep = dynamic_pointer_cast<Sheep>( target );
+		std::shared_ptr<Sheep> otherSheep = std::dynamic_pointer_cast<Sheep>( target );
 		std::shared_ptr<Sheep> sheep = std::shared_ptr<Sheep>( new Sheep(level) );
-		int color = getOffspringColor(dynamic_pointer_cast<Animal>(shared_from_this()), otherSheep);
+		int color = getOffspringColor(std::dynamic_pointer_cast<Animal>(shared_from_this()), otherSheep);
 		sheep->setColor(15 - color);
 		return sheep;
 	}
@@ -333,5 +333,5 @@ int Sheep::getOffspringColor(std::shared_ptr<Animal> animal, std::shared_ptr<Ani
 
 int Sheep::getDyeColor(std::shared_ptr<Animal> animal)
 {
-	return 15 - dynamic_pointer_cast<Sheep>(animal)->getColor();
+	return 15 - std::dynamic_pointer_cast<Sheep>(animal)->getColor();
 }
diff --git a/Minecraft.World/Entities/Mobs/Silverfish.cpp b/Minecraft.World/Entities/Mobs/Silverfish.cpp
index 11fef1385..fcf292f3a 100644
--- a/Minecraft.World/Entities/Mobs/Silverfish.cpp
+++ b/Minecraft.World/Entities/Mobs/Silverfish.cpp
@@ -84,7 +84,7 @@ void Silverfish::checkHurtTarget(std::shared_ptr<Entity> target, float d)
 	if (attackTime <= 0 && d < 1.2f && target->bb->y1 > bb->y0 && target->bb->y0 < bb->y1)
 	{
 		attackTime = 20;
-		DamageSource *damageSource = DamageSource::mobAttack( dynamic_pointer_cast<Mob>( shared_from_this() ) );
+		DamageSource *damageSource = DamageSource::mobAttack( std::dynamic_pointer_cast<Mob>( shared_from_this() ) );
 		target->hurt(damageSource, attackDamage);
 		delete damageSource;
 	}
diff --git a/Minecraft.World/Entities/Mobs/Skeleton.cpp b/Minecraft.World/Entities/Mobs/Skeleton.cpp
index 483a439ae..9ec92ea04 100644
--- a/Minecraft.World/Entities/Mobs/Skeleton.cpp
+++ b/Minecraft.World/Entities/Mobs/Skeleton.cpp
@@ -101,8 +101,8 @@ void Skeleton::aiStep()
 void Skeleton::die(DamageSource *source)
 {
 	Monster::die(source);
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( source->getEntity() );
-	if ( dynamic_pointer_cast<Arrow>( source->getDirectEntity() ) != NULL && player != NULL)
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( source->getEntity() );
+	if ( std::dynamic_pointer_cast<Arrow>( source->getDirectEntity() ) != NULL && player != NULL)
 	{
 		double xd = player->x - x;
 		double zd = player->z - z;
diff --git a/Minecraft.World/Entities/Mobs/Slime.cpp b/Minecraft.World/Entities/Mobs/Slime.cpp
index f3d905c6f..9331d5a5b 100644
--- a/Minecraft.World/Entities/Mobs/Slime.cpp
+++ b/Minecraft.World/Entities/Mobs/Slime.cpp
@@ -213,7 +213,7 @@ void Slime::playerTouch(std::shared_ptr<Player> player)
 		int size = getSize();
 		if (canSee(player) && this->distanceToSqr(player) < (0.6 * size) * (0.6 * size))
 		{
-			DamageSource *damageSource = DamageSource::mobAttack( dynamic_pointer_cast<Mob>( shared_from_this() ) );
+			DamageSource *damageSource = DamageSource::mobAttack( std::dynamic_pointer_cast<Mob>( shared_from_this() ) );
 			if (player->hurt(damageSource, getAttackDamage()))
 			{
 				level->playSound(shared_from_this(), eSoundType_MOB_SLIME_ATTACK, 1, (random->nextFloat() - random->nextFloat()) * 0.2f + 1.0f);
diff --git a/Minecraft.World/Entities/Mobs/SmallFireball.cpp b/Minecraft.World/Entities/Mobs/SmallFireball.cpp
index 108219961..0578fca11 100644
--- a/Minecraft.World/Entities/Mobs/SmallFireball.cpp
+++ b/Minecraft.World/Entities/Mobs/SmallFireball.cpp
@@ -27,7 +27,7 @@ void SmallFireball::onHit(HitResult *res)
 	{
 		if (res->entity != NULL)
 		{
-			DamageSource *damageSource = DamageSource::fireball(dynamic_pointer_cast<Fireball>(shared_from_this()),owner);
+			DamageSource *damageSource = DamageSource::fireball(std::dynamic_pointer_cast<Fireball>(shared_from_this()),owner);
 			if (!res->entity->isFireImmune() && res->entity->hurt(damageSource, 5))
 			{
 				res->entity->setOnFire(5);
diff --git a/Minecraft.World/Entities/Mobs/Snowball.cpp b/Minecraft.World/Entities/Mobs/Snowball.cpp
index 889b349ec..630949e09 100644
--- a/Minecraft.World/Entities/Mobs/Snowball.cpp
+++ b/Minecraft.World/Entities/Mobs/Snowball.cpp
@@ -34,7 +34,7 @@ void Snowball::onHit(HitResult *res)
 	if (res->entity != NULL)
 	{
 		int damage = 0;
-		if (dynamic_pointer_cast<Blaze>(res->entity) != NULL)
+		if (std::dynamic_pointer_cast<Blaze>(res->entity) != NULL)
 		{
 			damage = 3;
 		}
diff --git a/Minecraft.World/Entities/Mobs/ThrownEnderPearl.cpp b/Minecraft.World/Entities/Mobs/ThrownEnderPearl.cpp
index 5cf125998..51b863d92 100644
--- a/Minecraft.World/Entities/Mobs/ThrownEnderPearl.cpp
+++ b/Minecraft.World/Entities/Mobs/ThrownEnderPearl.cpp
@@ -47,7 +47,7 @@ void ThrownEnderpearl::onHit(HitResult *res)
 	{
 		// Fix for #67486 - TCR #001: BAS Game Stability: Customer Encountered: TU8: Code: Gameplay: The title crashes on Host's console when Client Player leaves the game before the Ender Pearl thrown by him touches the ground.
 		// If the owner has been removed, then ignore
-		std::shared_ptr<ServerPlayer> serverPlayer = dynamic_pointer_cast<ServerPlayer>(owner);
+		std::shared_ptr<ServerPlayer> serverPlayer = std::dynamic_pointer_cast<ServerPlayer>(owner);
 		if (serverPlayer != NULL && !serverPlayer->removed)
 		{
 			if(!serverPlayer->connection->done && serverPlayer->level == this->level)
diff --git a/Minecraft.World/Entities/Mobs/ThrownPotion.cpp b/Minecraft.World/Entities/Mobs/ThrownPotion.cpp
index 97c0378f2..1da274922 100644
--- a/Minecraft.World/Entities/Mobs/ThrownPotion.cpp
+++ b/Minecraft.World/Entities/Mobs/ThrownPotion.cpp
@@ -82,7 +82,7 @@ void ThrownPotion::onHit(HitResult *res)
 				for(AUTO_VAR(it, entitiesOfClass->begin()); it != entitiesOfClass->end(); ++it)
 				{
 					//std::shared_ptr<Entity> e = *it;
-					std::shared_ptr<Mob> e = dynamic_pointer_cast<Mob>( *it );
+					std::shared_ptr<Mob> e = std::dynamic_pointer_cast<Mob>( *it );
 					double dist = distanceToSqr(e);
 					if (dist < SPLASH_RANGE_SQ)
 					{
diff --git a/Minecraft.World/Entities/Mobs/Villager.cpp b/Minecraft.World/Entities/Mobs/Villager.cpp
index b1217ef30..946aee05a 100644
--- a/Minecraft.World/Entities/Mobs/Villager.cpp
+++ b/Minecraft.World/Entities/Mobs/Villager.cpp
@@ -158,7 +158,7 @@ bool Villager::interact(std::shared_ptr<Player> player)
 		{
 			// note: stop() logic is controlled by trading ai goal
 			setTradingPlayer(player);
-			player->openTrading(dynamic_pointer_cast<Merchant>(shared_from_this()));
+			player->openTrading(std::dynamic_pointer_cast<Merchant>(shared_from_this()));
 		}
 		return true;
 	}
@@ -290,7 +290,7 @@ void Villager::setLastHurtByMob(std::shared_ptr<Mob> mob)
 	{
 		_village->addAggressor(mob);
 
-		std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob);
+		std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mob);
 		if (player)
 		{
 			int amount = -1;
@@ -317,7 +317,7 @@ void Villager::die(DamageSource *source)
 		{
 			if ((sourceEntity->GetType() & eTYPE_PLAYER) == eTYPE_PLAYER)
 			{
-				std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(sourceEntity);
+				std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(sourceEntity);
 				_village->modifyStanding(player->getName(), -2);
 			}
 			else if ((sourceEntity->GetType() & eTYPE_ENEMY) == eTYPE_ENEMY)
diff --git a/Minecraft.World/Entities/Mobs/VillagerGolem.cpp b/Minecraft.World/Entities/Mobs/VillagerGolem.cpp
index c64ccc91d..e3a6bb036 100644
--- a/Minecraft.World/Entities/Mobs/VillagerGolem.cpp
+++ b/Minecraft.World/Entities/Mobs/VillagerGolem.cpp
@@ -137,7 +137,7 @@ bool VillagerGolem::doHurtTarget(std::shared_ptr<Entity> target)
 {
 	attackAnimationTick = 10;
 	level->broadcastEntityEvent(shared_from_this(), EntityEvent::START_ATTACKING);
-	bool hurt = target->hurt(DamageSource::mobAttack(dynamic_pointer_cast<Mob>(shared_from_this())), 7 + random->nextInt(15));
+	bool hurt = target->hurt(DamageSource::mobAttack(std::dynamic_pointer_cast<Mob>(shared_from_this())), 7 + random->nextInt(15));
 	if (hurt) target->yd += 0.4f;
 	level->playSound(shared_from_this(), eSoundType_MOB_IRONGOLEM_THROW, 1, 1);
 	return hurt;
diff --git a/Minecraft.World/Entities/Mobs/Wolf.cpp b/Minecraft.World/Entities/Mobs/Wolf.cpp
index f463aa784..c2effb3bc 100644
--- a/Minecraft.World/Entities/Mobs/Wolf.cpp
+++ b/Minecraft.World/Entities/Mobs/Wolf.cpp
@@ -63,7 +63,7 @@ bool Wolf::useNewAi()
 void Wolf::setTarget(std::shared_ptr<Mob> target)
 {
 	TamableAnimal::setTarget(target);
-	if ( dynamic_pointer_cast<Player>(target) == NULL )
+	if ( std::dynamic_pointer_cast<Player>(target) == NULL )
 	{
 		setAngry(false);
 	}
@@ -294,7 +294,7 @@ bool Wolf::hurt(DamageSource *source, int dmg)
 	if (isInvulnerable()) return false;
 	std::shared_ptr<Entity> sourceEntity = source->getEntity();
 	sitGoal->wantToSit(false);
-	if (sourceEntity != NULL && !(dynamic_pointer_cast<Player>(sourceEntity) != NULL || dynamic_pointer_cast<Arrow>(sourceEntity) != NULL)) 
+	if (sourceEntity != NULL && !(std::dynamic_pointer_cast<Player>(sourceEntity) != NULL || std::dynamic_pointer_cast<Arrow>(sourceEntity) != NULL)) 
 	{
 		// take half damage from non-players and arrows
 		dmg = (dmg + 1) / 2;
@@ -305,7 +305,7 @@ bool Wolf::hurt(DamageSource *source, int dmg)
 bool Wolf::doHurtTarget(std::shared_ptr<Entity> target)
 {
 	int damage = isTame() ? 4 : 2;
-	return target->hurt(DamageSource::mobAttack(dynamic_pointer_cast<Mob>(shared_from_this())), damage);
+	return target->hurt(DamageSource::mobAttack(std::dynamic_pointer_cast<Mob>(shared_from_this())), damage);
 }
 
 void Wolf::tame(const std::wstring &wsOwnerUUID, bool bDisplayTamingParticles, bool bSetSitting) 
@@ -536,7 +536,7 @@ bool Wolf::canMate(std::shared_ptr<Animal> animal)
 {
 	if (animal == shared_from_this()) return false;
 	if (!isTame()) return false;
-	std::shared_ptr<Wolf> partner = dynamic_pointer_cast<Wolf>(animal);
+	std::shared_ptr<Wolf> partner = std::dynamic_pointer_cast<Wolf>(animal);
 	if (partner == NULL) return false;
 	if (!partner->isTame()) return false;
 	if (partner->isSitting()) return false;
diff --git a/Minecraft.World/Entities/Monster.cpp b/Minecraft.World/Entities/Monster.cpp
index 95f74179a..3624f0b4c 100644
--- a/Minecraft.World/Entities/Monster.cpp
+++ b/Minecraft.World/Entities/Monster.cpp
@@ -94,19 +94,19 @@ bool Monster::doHurtTarget(std::shared_ptr<Entity> target)
 		dmg -= (2 << getEffect(MobEffect::weakness)->getAmplifier());
 	}
 
-	DamageSource *damageSource = DamageSource::mobAttack(dynamic_pointer_cast<Mob>( shared_from_this() ) );
+	DamageSource *damageSource = DamageSource::mobAttack(std::dynamic_pointer_cast<Mob>( shared_from_this() ) );
 	bool didHurt = target->hurt(damageSource, dmg);
 	delete damageSource;
 
 	if (didHurt)
 	{
-		int fireAspect = EnchantmentHelper::getFireAspect(dynamic_pointer_cast<Mob>(shared_from_this()));
+		int fireAspect = EnchantmentHelper::getFireAspect(std::dynamic_pointer_cast<Mob>(shared_from_this()));
 		if (fireAspect > 0)
 		{
 			target->setOnFire(fireAspect * 4);
 		}
 
-		std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(target);
+		std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(target);
 		if (mob != NULL)
 		{
 			ThornsEnchantment::doThornsAfterAttack(shared_from_this(), mob, random);
diff --git a/Minecraft.World/Items/BucketItem.cpp b/Minecraft.World/Items/BucketItem.cpp
index e7ae4f0ed..4588a3633 100644
--- a/Minecraft.World/Items/BucketItem.cpp
+++ b/Minecraft.World/Items/BucketItem.cpp
@@ -120,7 +120,7 @@ std::shared_ptr<ItemInstance> BucketItem::use(std::shared_ptr<ItemInstance> item
 		if (!level->mayInteract(player, xt, yt, zt,content))
 		{
 			app.DebugPrintf("!!!!!!!!!!! Can't place that here\n");
-			std::shared_ptr<ServerPlayer> servPlayer = dynamic_pointer_cast<ServerPlayer>(player);
+			std::shared_ptr<ServerPlayer> servPlayer = std::dynamic_pointer_cast<ServerPlayer>(player);
 			if( servPlayer != NULL )
 			{
 				app.DebugPrintf("Sending ChatPacket::e_ChatCannotPlaceLava to player\n");
diff --git a/Minecraft.World/Items/CarrotOnAStickItem.cpp b/Minecraft.World/Items/CarrotOnAStickItem.cpp
index 99dae0937..fd2e9d2fc 100644
--- a/Minecraft.World/Items/CarrotOnAStickItem.cpp
+++ b/Minecraft.World/Items/CarrotOnAStickItem.cpp
@@ -25,7 +25,7 @@ std::shared_ptr<ItemInstance> CarrotOnAStickItem::use(std::shared_ptr<ItemInstan
 {
 	if (player->isRiding())
 	{
-		std::shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(player->riding);
+		std::shared_ptr<Pig> pig = std::dynamic_pointer_cast<Pig>(player->riding);
 		if(pig)
 		{
 			if (pig->getControlGoal()->canBoost() && itemInstance->getMaxDamage() - itemInstance->getAuxValue() >= 7)
diff --git a/Minecraft.World/Items/DyePowderItem.cpp b/Minecraft.World/Items/DyePowderItem.cpp
index a24fda545..47794339f 100644
--- a/Minecraft.World/Items/DyePowderItem.cpp
+++ b/Minecraft.World/Items/DyePowderItem.cpp
@@ -291,9 +291,9 @@ mainloop: continue;
 
 bool DyePowderItem::interactEnemy(std::shared_ptr<ItemInstance> itemInstance, std::shared_ptr<Mob> mob) 
 {
-	if (dynamic_pointer_cast<Sheep>( mob ) != NULL) 
+	if (std::dynamic_pointer_cast<Sheep>( mob ) != NULL) 
 	{
-		std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(mob);
+		std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(mob);
 		// convert to tile-based color value (0 is white instead of black)
 		int newColor = ClothTile::getTileDataForItemAuxValue(itemInstance->getAuxValue());
 		if (!sheep->isSheared() && sheep->getColor() != newColor) 
diff --git a/Minecraft.World/Items/EggItem.cpp b/Minecraft.World/Items/EggItem.cpp
index 0442da4ff..915a4be45 100644
--- a/Minecraft.World/Items/EggItem.cpp
+++ b/Minecraft.World/Items/EggItem.cpp
@@ -25,7 +25,7 @@ std::shared_ptr<ItemInstance> EggItem::use(std::shared_ptr<ItemInstance> instanc
 	{
 		instance->count--;
 	}
-    level->playSound( dynamic_pointer_cast<Entity>(player), eSoundType_RANDOM_BOW, 0.5f, 0.4f / (random->nextFloat() * 0.4f + 0.8f));
-    if (!level->isClientSide) level->addEntity( std::shared_ptr<ThrownEgg>( new ThrownEgg(level, dynamic_pointer_cast<Mob>( player )) ));
+    level->playSound( std::dynamic_pointer_cast<Entity>(player), eSoundType_RANDOM_BOW, 0.5f, 0.4f / (random->nextFloat() * 0.4f + 0.8f));
+    if (!level->isClientSide) level->addEntity( std::shared_ptr<ThrownEgg>( new ThrownEgg(level, std::dynamic_pointer_cast<Mob>( player )) ));
     return instance;
 }
diff --git a/Minecraft.World/Items/HangingEntityItem.cpp b/Minecraft.World/Items/HangingEntityItem.cpp
index 03cf121cb..a0f6d720f 100644
--- a/Minecraft.World/Items/HangingEntityItem.cpp
+++ b/Minecraft.World/Items/HangingEntityItem.cpp
@@ -72,13 +72,13 @@ std::shared_ptr<HangingEntity> HangingEntityItem::createEntity(Level *level, int
 		std::shared_ptr<Painting> painting = std::shared_ptr<Painting>(new Painting(level, x, y, z, dir));
 		painting->PaintingPostConstructor(dir);
 		
-		return dynamic_pointer_cast<HangingEntity> (painting);
+		return std::dynamic_pointer_cast<HangingEntity> (painting);
 	} 
 	else if (eType == eTYPE_ITEM_FRAME) 
 	{
 		std::shared_ptr<ItemFrame> itemFrame = std::shared_ptr<ItemFrame>(new ItemFrame(level, x, y, z, dir));
 
-		return dynamic_pointer_cast<HangingEntity> (itemFrame);
+		return std::dynamic_pointer_cast<HangingEntity> (itemFrame);
 	} 
 	else 
 	{
diff --git a/Minecraft.World/Items/ItemInstance.cpp b/Minecraft.World/Items/ItemInstance.cpp
index 0984fdd6f..96e4aebf6 100644
--- a/Minecraft.World/Items/ItemInstance.cpp
+++ b/Minecraft.World/Items/ItemInstance.cpp
@@ -216,7 +216,7 @@ void ItemInstance::hurt(int i, std::shared_ptr<Mob> owner)
         return;
     }
 
-	std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(owner);
+	std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(owner);
  	if (i > 0 && player != NULL)
 	{
 		int enchanted = EnchantmentHelper::getDigDurability(player->inventory);
diff --git a/Minecraft.World/Items/MapItem.cpp b/Minecraft.World/Items/MapItem.cpp
index 805a99259..e3890c028 100644
--- a/Minecraft.World/Items/MapItem.cpp
+++ b/Minecraft.World/Items/MapItem.cpp
@@ -22,7 +22,7 @@ MapItem::MapItem(int id) : ComplexItem(id)
 std::shared_ptr<MapItemSavedData> MapItem::getSavedData(short idNum, Level *level)
 {	
 	std::wstring id = std::wstring( L"map_" ) + _toString(idNum);
-	std::shared_ptr<MapItemSavedData> mapItemSavedData = dynamic_pointer_cast<MapItemSavedData>(level->getSavedData(typeid(MapItemSavedData), id));
+	std::shared_ptr<MapItemSavedData> mapItemSavedData = std::dynamic_pointer_cast<MapItemSavedData>(level->getSavedData(typeid(MapItemSavedData), id));
 
 	if (mapItemSavedData == NULL) 
 	{
@@ -45,7 +45,7 @@ std::shared_ptr<MapItemSavedData> MapItem::getSavedData(std::shared_ptr<ItemInst
 	MemSect(31);
 	std::wstring id = std::wstring( L"map_" ) + _toString(itemInstance->getAuxValue() );
 	MemSect(0);
-	std::shared_ptr<MapItemSavedData> mapItemSavedData = dynamic_pointer_cast<MapItemSavedData>( level->getSavedData(typeid(MapItemSavedData), id ) );
+	std::shared_ptr<MapItemSavedData> mapItemSavedData = std::dynamic_pointer_cast<MapItemSavedData>( level->getSavedData(typeid(MapItemSavedData), id ) );
 
 	bool newData = false;
 	if (mapItemSavedData == NULL)
@@ -264,9 +264,9 @@ void MapItem::inventoryTick(std::shared_ptr<ItemInstance> itemInstance, Level *l
 	if (level->isClientSide) return;
 
 	std::shared_ptr<MapItemSavedData> data = getSavedData(itemInstance, level);
-	if (dynamic_pointer_cast<Player>(owner) != NULL) 
+	if (std::dynamic_pointer_cast<Player>(owner) != NULL) 
 	{
-		std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(owner);
+		std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(owner);
 
 		// 4J Stu - If the player has a map that belongs to another player, then merge the data over and change this map id to the owners id
 		int ownersAuxValue = level->getAuxValueForMap(player->getXuid(), data->dimension, data->x, data->z, data->scale);
diff --git a/Minecraft.World/Items/MonsterPlacerItem.cpp b/Minecraft.World/Items/MonsterPlacerItem.cpp
index ed4c4435b..7c52b7c04 100644
--- a/Minecraft.World/Items/MonsterPlacerItem.cpp
+++ b/Minecraft.World/Items/MonsterPlacerItem.cpp
@@ -181,7 +181,7 @@ bool MonsterPlacerItem::useOn(std::shared_ptr<ItemInstance> itemInstance, std::s
 		// 4J Stu - Force adding this as a tile update
 		level->setTile(x,y,z,0);
 		level->setTile(x,y,z,Tile::mobSpawner_Id);
-		std::shared_ptr<MobSpawnerTileEntity> mste = dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x,y,z) );
+		std::shared_ptr<MobSpawnerTileEntity> mste = std::dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x,y,z) );
 		if(mste != NULL)
 		{
 			mste->setEntityId( EntityIO::getEncodeId(itemInstance->getAuxValue()) );
@@ -267,7 +267,7 @@ std::shared_ptr<Entity> MonsterPlacerItem::spawnMobAt(Level *level, int mobId, d
 	{
 		newEntity = canSpawn(mobId, level, piResult);
 
-		std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(newEntity);
+		std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(newEntity);
 		if (mob)
 		{
 			newEntity->moveTo(x, y, z, Mth::wrapDegrees(level->random->nextFloat() * 360), 0);
diff --git a/Minecraft.World/Items/SaddleItem.cpp b/Minecraft.World/Items/SaddleItem.cpp
index 6356c2d68..6932a5348 100644
--- a/Minecraft.World/Items/SaddleItem.cpp
+++ b/Minecraft.World/Items/SaddleItem.cpp
@@ -11,9 +11,9 @@ SaddleItem::SaddleItem(int id) : Item(id)
 
 bool SaddleItem::interactEnemy(std::shared_ptr<ItemInstance> itemInstance, std::shared_ptr<Mob> mob) 
 {
-    if ( dynamic_pointer_cast<Pig>(mob) )
+    if ( std::dynamic_pointer_cast<Pig>(mob) )
 	{
-        std::shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(mob);
+        std::shared_ptr<Pig> pig = std::dynamic_pointer_cast<Pig>(mob);
         if (!pig->hasSaddle() && !pig->isBaby()) 
 		{
             pig->setSaddle(true);
diff --git a/Minecraft.World/Items/SignItem.cpp b/Minecraft.World/Items/SignItem.cpp
index 3c53ce38a..3e8968cac 100644
--- a/Minecraft.World/Items/SignItem.cpp
+++ b/Minecraft.World/Items/SignItem.cpp
@@ -43,7 +43,7 @@ bool SignItem::useOn(std::shared_ptr<ItemInstance> instance, std::shared_ptr<Pla
 		}
 
 		instance->count--;
-		std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>( level->getTileEntity(x, y, z) );
+		std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>( level->getTileEntity(x, y, z) );
 		if (ste != NULL) player->openTextEdit(ste);
 
 		// 4J-JEV: Hook for durango 'BlockPlaced' event.
diff --git a/Minecraft.World/Items/TileItems/SkullItem.cpp b/Minecraft.World/Items/TileItems/SkullItem.cpp
index 668a3f92b..07b3ff487 100644
--- a/Minecraft.World/Items/TileItems/SkullItem.cpp
+++ b/Minecraft.World/Items/TileItems/SkullItem.cpp
@@ -46,7 +46,7 @@ bool SkullItem::useOn(std::shared_ptr<ItemInstance> instance, std::shared_ptr<Pl
 		}
 
 		std::shared_ptr<TileEntity> skullTE = level->getTileEntity(x, y, z);
-		std::shared_ptr<SkullTileEntity> skull = dynamic_pointer_cast<SkullTileEntity>(skullTE);
+		std::shared_ptr<SkullTileEntity> skull = std::dynamic_pointer_cast<SkullTileEntity>(skullTE);
 
 		if (skull != NULL)
 		{
diff --git a/Minecraft.World/Level/Explosion.cpp b/Minecraft.World/Level/Explosion.cpp
index 6b037c25d..9a1fc3466 100644
--- a/Minecraft.World/Level/Explosion.cpp
+++ b/Minecraft.World/Level/Explosion.cpp
@@ -149,7 +149,7 @@ void Explosion::explode()
 			e->yd += ya * push;
 			e->zd += za * push;					
 
-			std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
+			std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
 			if (player != NULL)
 			{
 				//app.DebugPrintf("Adding player knockback (%f,%f,%f)\n", xa * pow, ya * pow, za * pow);
diff --git a/Minecraft.World/Level/Level.cpp b/Minecraft.World/Level/Level.cpp
index 8fa861d71..89ff0e193 100644
--- a/Minecraft.World/Level/Level.cpp
+++ b/Minecraft.World/Level/Level.cpp
@@ -568,7 +568,7 @@ Level::Level(std::shared_ptr<LevelStorage> levelStorage, const std::wstring& nam
 	if( !this->levelData->useNewSeaLevel() ) seaLevel = Level::genDepth / 2;		// 4J added - sea level is one unit lower since 1.8.2, maintain older height for old levels
 	this->savedDataStorage = new SavedDataStorage(levelStorage.get());
 
-	std::shared_ptr<Villages> savedVillages = dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID));
+	std::shared_ptr<Villages> savedVillages = std::dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID));
 	if (savedVillages == NULL)
 	{
 		villages = std::shared_ptr<Villages>(new Villages(this));
@@ -597,7 +597,7 @@ Level::Level(Level *level, Dimension *dimension)
 	if( !this->levelData->useNewSeaLevel() ) seaLevel = Level::genDepth / 2;		// 4J added - sea level is one unit lower since 1.8.2, maintain older height for old levels
 	this->savedDataStorage = new SavedDataStorage( levelStorage.get() );
 	
-	std::shared_ptr<Villages> savedVillages = dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID));
+	std::shared_ptr<Villages> savedVillages = std::dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID));
 	if (savedVillages == NULL)
 	{
 		villages = std::shared_ptr<Villages>(new Villages(this));
@@ -636,7 +636,7 @@ void Level::_init(std::shared_ptr<LevelStorage>levelStorage, const std::wstring&
 	this->levelStorage = levelStorage;//std::shared_ptr<LevelStorage>(levelStorage);
 	this->savedDataStorage = new SavedDataStorage(levelStorage.get());
 
-	std::shared_ptr<Villages> savedVillages = dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID));
+	std::shared_ptr<Villages> savedVillages = std::dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID));
 	if (savedVillages == NULL)
 	{
 		villages = std::shared_ptr<Villages>(new Villages(this));
@@ -1667,16 +1667,16 @@ bool Level::addEntity(std::shared_ptr<Entity> e)
 	}
 
 	bool forced = false;
-	if (dynamic_pointer_cast<Player>( e ) != NULL)
+	if (std::dynamic_pointer_cast<Player>( e ) != NULL)
 	{
 		forced = true;
 	}
 
 	if (forced || hasChunk(xc, zc))
 	{
-		if (dynamic_pointer_cast<Player>( e ) != NULL)
+		if (std::dynamic_pointer_cast<Player>( e ) != NULL)
 		{
-			std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
+			std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
 
 			// 4J Stu - Added so we don't continually add the player to the players list while they are dead
 			if( find( players.begin(), players.end(), e ) == players.end() )
@@ -1744,11 +1744,11 @@ void Level::removeEntity(std::shared_ptr<Entity> e)
 		e->ride(nullptr);
 	}
 	e->remove();
-	if (dynamic_pointer_cast<Player>( e ) != NULL)
+	if (std::dynamic_pointer_cast<Player>( e ) != NULL)
 	{
 		std::vector<std::shared_ptr<Player> >::iterator it = players.begin();
 		std::vector<std::shared_ptr<Player> >::iterator itEnd = players.end();
-		while( it != itEnd && *it != dynamic_pointer_cast<Player>(e) )
+		while( it != itEnd && *it != std::dynamic_pointer_cast<Player>(e) )
 			it++;
 
 		if( it != itEnd )
@@ -1766,11 +1766,11 @@ void Level::removeEntityImmediately(std::shared_ptr<Entity> e)
 {
 	e->remove();
 
-	if (dynamic_pointer_cast<Player>( e ) != NULL)
+	if (std::dynamic_pointer_cast<Player>( e ) != NULL)
 	{
 		std::vector<std::shared_ptr<Player> >::iterator it = players.begin();
 		std::vector<std::shared_ptr<Player> >::iterator itEnd = players.end();
-		while( it != itEnd && *it != dynamic_pointer_cast<Player>(e) )
+		while( it != itEnd && *it != std::dynamic_pointer_cast<Player>(e) )
 			it++;
 
 		if( it != itEnd )
@@ -2286,7 +2286,7 @@ void Level::tickEntities()
 		if (!e->removed)
 		{
 #ifndef _FINAL_BUILD
-			if(!( app.DebugSettingsOn() && app.GetMobsDontTickEnabled() && (dynamic_pointer_cast<Mob>(e) != NULL) &&  (dynamic_pointer_cast<Player>(e) == NULL)))
+			if(!( app.DebugSettingsOn() && app.GetMobsDontTickEnabled() && (std::dynamic_pointer_cast<Mob>(e) != NULL) &&  (std::dynamic_pointer_cast<Player>(e) == NULL)))
 #endif			
 			{
 				tick(e);
diff --git a/Minecraft.World/Level/LevelChunk.cpp b/Minecraft.World/Level/LevelChunk.cpp
index b83b2e08a..5d7d1aded 100644
--- a/Minecraft.World/Level/LevelChunk.cpp
+++ b/Minecraft.World/Level/LevelChunk.cpp
@@ -1639,10 +1639,10 @@ void LevelChunk::getEntitiesOfClass(const std::type_info& ec, AABB *bb, std::vec
 
 			bool isAssignableFrom = false;
 			// Some special cases where the base class is a general type that our class may be derived from, otherwise do a direct comparison of std::type_info
-			if( ec == typeid(Player) ) { if( dynamic_pointer_cast<Player>(e) != NULL )  isAssignableFrom = true; }
-			else if ( ec == typeid(Mob) )  { if( dynamic_pointer_cast<Mob>(e) != NULL )  isAssignableFrom = true; }
-			else if ( ec == typeid(Monster) )  { if( dynamic_pointer_cast<Monster>(e) != NULL )  isAssignableFrom = true; }
-			else if ( ec == typeid(Zombie) )  { if( dynamic_pointer_cast<Zombie>(e) != NULL )  isAssignableFrom = true; }
+			if( ec == typeid(Player) ) { if( std::dynamic_pointer_cast<Player>(e) != NULL )  isAssignableFrom = true; }
+			else if ( ec == typeid(Mob) )  { if( std::dynamic_pointer_cast<Mob>(e) != NULL )  isAssignableFrom = true; }
+			else if ( ec == typeid(Monster) )  { if( std::dynamic_pointer_cast<Monster>(e) != NULL )  isAssignableFrom = true; }
+			else if ( ec == typeid(Zombie) )  { if( std::dynamic_pointer_cast<Zombie>(e) != NULL )  isAssignableFrom = true; }
 			else if(e != NULL && ec == typeid(*(e.get())) ) isAssignableFrom = true;
             if (isAssignableFrom && e->bb->intersects(bb)) es.push_back(e);
 			// 4J - note needs to be equivalent to baseClass.isAssignableFrom(e.getClass())
diff --git a/Minecraft.World/Level/Storage/MapItemSavedData.cpp b/Minecraft.World/Level/Storage/MapItemSavedData.cpp
index 8e1dc10f9..908c599c1 100644
--- a/Minecraft.World/Level/Storage/MapItemSavedData.cpp
+++ b/Minecraft.World/Level/Storage/MapItemSavedData.cpp
@@ -125,7 +125,7 @@ charArray MapItemSavedData::HoldingPlayer::nextUpdatePacket(std::shared_ptr<Item
 		}
 		delete data.data;
 	}
-	std::shared_ptr<ServerPlayer> servPlayer = dynamic_pointer_cast<ServerPlayer>(player);
+	std::shared_ptr<ServerPlayer> servPlayer = std::dynamic_pointer_cast<ServerPlayer>(player);
 	for (int d = 0; d < 10; d++)
 	{
 		int column = (tick * 11) % (MapItem::IMAGE_WIDTH);
diff --git a/Minecraft.World/Level/Storage/SavedDataStorage.cpp b/Minecraft.World/Level/Storage/SavedDataStorage.cpp
index 6b313cd38..7c6607378 100644
--- a/Minecraft.World/Level/Storage/SavedDataStorage.cpp
+++ b/Minecraft.World/Level/Storage/SavedDataStorage.cpp
@@ -32,16 +32,16 @@ std::shared_ptr<SavedData> SavedDataStorage::get(const std::type_info& clazz, co
 		ConsoleSavePath file = levelStorage->getDataFile(id);
 		if (!file.getName().empty() && levelStorage->getSaveFile()->doesFileExist( file ) ) 
 		{
-			// mob = dynamic_pointer_cast<Mob>(Mob::_class->newInstance( level ));
+			// mob = std::dynamic_pointer_cast<Mob>(Mob::_class->newInstance( level ));
 		    //data = clazz.getConstructor(String.class).newInstance(id);
 
 			if( clazz == typeid(MapItemSavedData) )
 			{
-				data = dynamic_pointer_cast<SavedData>( std::shared_ptr<MapItemSavedData>(new MapItemSavedData(id)) );
+				data = std::dynamic_pointer_cast<SavedData>( std::shared_ptr<MapItemSavedData>(new MapItemSavedData(id)) );
 			}
 			else if( clazz == typeid(Villages) )
 			{
-				data = dynamic_pointer_cast<SavedData>( std::shared_ptr<Villages>(new Villages(id) ) );
+				data = std::dynamic_pointer_cast<SavedData>( std::shared_ptr<Villages>(new Villages(id) ) );
 			}
 			else
 			{
diff --git a/Minecraft.World/Network/Packets/AddGlobalEntityPacket.cpp b/Minecraft.World/Network/Packets/AddGlobalEntityPacket.cpp
index 5bb235246..c0bdae6a7 100644
--- a/Minecraft.World/Network/Packets/AddGlobalEntityPacket.cpp
+++ b/Minecraft.World/Network/Packets/AddGlobalEntityPacket.cpp
@@ -26,7 +26,7 @@ AddGlobalEntityPacket::AddGlobalEntityPacket(std::shared_ptr<Entity> e)
     x = Mth::floor(e->x * 32);
     y = Mth::floor(e->y * 32);
     z = Mth::floor(e->z * 32);
-	if (dynamic_pointer_cast<LightningBolt>(e) != NULL) 
+	if (std::dynamic_pointer_cast<LightningBolt>(e) != NULL) 
 	{
 		this->type = LIGHTNING;
 	}
diff --git a/Minecraft.World/Network/Packets/ClientCommandPacket.cpp b/Minecraft.World/Network/Packets/ClientCommandPacket.cpp
index bb88a6c4f..00bf2bc04 100644
--- a/Minecraft.World/Network/Packets/ClientCommandPacket.cpp
+++ b/Minecraft.World/Network/Packets/ClientCommandPacket.cpp
@@ -24,7 +24,7 @@ void ClientCommandPacket::write(DataOutputStream *dos)
 
 void ClientCommandPacket::handle(PacketListener *listener)
 {
-	listener->handleClientCommand(dynamic_pointer_cast<ClientCommandPacket>(shared_from_this()));
+	listener->handleClientCommand(std::dynamic_pointer_cast<ClientCommandPacket>(shared_from_this()));
 }
 
 int ClientCommandPacket::getEstimatedSize()
diff --git a/Minecraft.World/Network/Packets/MoveEntityPacket.cpp b/Minecraft.World/Network/Packets/MoveEntityPacket.cpp
index 7301b1e9f..6c1f8cd3f 100644
--- a/Minecraft.World/Network/Packets/MoveEntityPacket.cpp
+++ b/Minecraft.World/Network/Packets/MoveEntityPacket.cpp
@@ -60,7 +60,7 @@ bool MoveEntityPacket::canBeInvalidated()
 
 bool MoveEntityPacket::isInvalidatedBy(std::shared_ptr<Packet> packet)
 {
-	std::shared_ptr<MoveEntityPacket> target = dynamic_pointer_cast<MoveEntityPacket>(packet);
+	std::shared_ptr<MoveEntityPacket> target = std::dynamic_pointer_cast<MoveEntityPacket>(packet);
 	return target != NULL && target->id == id;
 }
 
diff --git a/Minecraft.World/Network/Packets/MoveEntityPacketSmall.cpp b/Minecraft.World/Network/Packets/MoveEntityPacketSmall.cpp
index 120c73342..ff05bb0a4 100644
--- a/Minecraft.World/Network/Packets/MoveEntityPacketSmall.cpp
+++ b/Minecraft.World/Network/Packets/MoveEntityPacketSmall.cpp
@@ -67,7 +67,7 @@ bool MoveEntityPacketSmall::canBeInvalidated()
 
 bool MoveEntityPacketSmall::isInvalidatedBy(std::shared_ptr<Packet> packet)
 {
-	std::shared_ptr<MoveEntityPacketSmall> target = dynamic_pointer_cast<MoveEntityPacketSmall>(packet);
+	std::shared_ptr<MoveEntityPacketSmall> target = std::dynamic_pointer_cast<MoveEntityPacketSmall>(packet);
 	return target != NULL && target->id == id;
 }
 
diff --git a/Minecraft.World/Network/Packets/RotateHeadPacket.cpp b/Minecraft.World/Network/Packets/RotateHeadPacket.cpp
index 04606baa3..b7036b239 100644
--- a/Minecraft.World/Network/Packets/RotateHeadPacket.cpp
+++ b/Minecraft.World/Network/Packets/RotateHeadPacket.cpp
@@ -41,7 +41,7 @@ bool RotateHeadPacket::canBeInvalidated()
 
 bool RotateHeadPacket::isInvalidatedBy(std::shared_ptr<Packet> packet)
 {
-	std::shared_ptr<RotateHeadPacket> target = dynamic_pointer_cast<RotateHeadPacket>(packet);
+	std::shared_ptr<RotateHeadPacket> target = std::dynamic_pointer_cast<RotateHeadPacket>(packet);
 	return target->id == id;
 }
 
diff --git a/Minecraft.World/Network/Packets/SetEntityMotionPacket.cpp b/Minecraft.World/Network/Packets/SetEntityMotionPacket.cpp
index e371a32c5..b21a34ced 100644
--- a/Minecraft.World/Network/Packets/SetEntityMotionPacket.cpp
+++ b/Minecraft.World/Network/Packets/SetEntityMotionPacket.cpp
@@ -108,6 +108,6 @@ bool SetEntityMotionPacket::canBeInvalidated()
 
 bool SetEntityMotionPacket::isInvalidatedBy(std::shared_ptr<Packet> packet)
 {
-	std::shared_ptr<SetEntityMotionPacket> target = dynamic_pointer_cast<SetEntityMotionPacket>(packet);
+	std::shared_ptr<SetEntityMotionPacket> target = std::dynamic_pointer_cast<SetEntityMotionPacket>(packet);
 	return target->id == id;
 }
diff --git a/Minecraft.World/Network/Packets/SetEquippedItemPacket.cpp b/Minecraft.World/Network/Packets/SetEquippedItemPacket.cpp
index 08b458bb5..2b79d0e7f 100644
--- a/Minecraft.World/Network/Packets/SetEquippedItemPacket.cpp
+++ b/Minecraft.World/Network/Packets/SetEquippedItemPacket.cpp
@@ -64,6 +64,6 @@ bool SetEquippedItemPacket::canBeInvalidated()
 
 bool SetEquippedItemPacket::isInvalidatedBy(std::shared_ptr<Packet> packet)
 {
-	std::shared_ptr<SetEquippedItemPacket> target = dynamic_pointer_cast<SetEquippedItemPacket>(packet);
+	std::shared_ptr<SetEquippedItemPacket> target = std::dynamic_pointer_cast<SetEquippedItemPacket>(packet);
 	return target->entity == entity && target->slot == slot;
 }
\ No newline at end of file
diff --git a/Minecraft.World/Network/Packets/SetRidingPacket.cpp b/Minecraft.World/Network/Packets/SetRidingPacket.cpp
index 836ff4203..012346370 100644
--- a/Minecraft.World/Network/Packets/SetRidingPacket.cpp
+++ b/Minecraft.World/Network/Packets/SetRidingPacket.cpp
@@ -48,6 +48,6 @@ bool SetRidingPacket::canBeInvalidated()
 
 bool SetRidingPacket::isInvalidatedBy(std::shared_ptr<Packet> packet)
 {
-	std::shared_ptr<SetRidingPacket> target = dynamic_pointer_cast<SetRidingPacket>(packet);
+	std::shared_ptr<SetRidingPacket> target = std::dynamic_pointer_cast<SetRidingPacket>(packet);
 	return target->riderId == riderId;
 }
diff --git a/Minecraft.World/Network/Packets/TeleportEntityPacket.cpp b/Minecraft.World/Network/Packets/TeleportEntityPacket.cpp
index 009f98928..dbf386252 100644
--- a/Minecraft.World/Network/Packets/TeleportEntityPacket.cpp
+++ b/Minecraft.World/Network/Packets/TeleportEntityPacket.cpp
@@ -86,6 +86,6 @@ bool TeleportEntityPacket::canBeInvalidated()
 
 bool TeleportEntityPacket::isInvalidatedBy(std::shared_ptr<Packet> packet)
 {
-	std::shared_ptr<TeleportEntityPacket> target = dynamic_pointer_cast<TeleportEntityPacket>(packet);
+	std::shared_ptr<TeleportEntityPacket> target = std::dynamic_pointer_cast<TeleportEntityPacket>(packet);
 	return target->id == id;
 }
\ No newline at end of file
diff --git a/Minecraft.World/Network/Packets/TileDestructionPacket.cpp b/Minecraft.World/Network/Packets/TileDestructionPacket.cpp
index 80dce738d..f8b1768fb 100644
--- a/Minecraft.World/Network/Packets/TileDestructionPacket.cpp
+++ b/Minecraft.World/Network/Packets/TileDestructionPacket.cpp
@@ -80,6 +80,6 @@ bool TileDestructionPacket::canBeInvalidated()
 
 bool TileDestructionPacket::isInvalidatedBy(std::shared_ptr<Packet> packet)
 {
-	std::shared_ptr<TileDestructionPacket> target = dynamic_pointer_cast<TileDestructionPacket>(packet);
+	std::shared_ptr<TileDestructionPacket> target = std::dynamic_pointer_cast<TileDestructionPacket>(packet);
 	return target->id == id;
 }
\ No newline at end of file
diff --git a/Minecraft.World/Network/Packets/UpdateMobEffectPacket.cpp b/Minecraft.World/Network/Packets/UpdateMobEffectPacket.cpp
index fbfb8e107..df8988701 100644
--- a/Minecraft.World/Network/Packets/UpdateMobEffectPacket.cpp
+++ b/Minecraft.World/Network/Packets/UpdateMobEffectPacket.cpp
@@ -55,6 +55,6 @@ bool UpdateMobEffectPacket::canBeInvalidated()
 
 bool UpdateMobEffectPacket::isInvalidatedBy(std::shared_ptr<Packet> packet)
 {
-	std::shared_ptr<UpdateMobEffectPacket> target = dynamic_pointer_cast<UpdateMobEffectPacket>(packet);
+	std::shared_ptr<UpdateMobEffectPacket> target = std::dynamic_pointer_cast<UpdateMobEffectPacket>(packet);
 	return target->entityId == entityId && target->effectId == effectId;
 }
\ No newline at end of file
diff --git a/Minecraft.World/Player/Player.cpp b/Minecraft.World/Player/Player.cpp
index 5e9b13f0a..33a737bc4 100644
--- a/Minecraft.World/Player/Player.cpp
+++ b/Minecraft.World/Player/Player.cpp
@@ -215,7 +215,7 @@ void Player::releaseUsingItem()
 {
 	if (useItem != NULL)
 	{
-		useItem->releaseUsing(level, dynamic_pointer_cast<Player>( shared_from_this() ), useItemDuration);
+		useItem->releaseUsing(level, std::dynamic_pointer_cast<Player>( shared_from_this() ), useItemDuration);
 
 		// 4J Stu - Fix for various bugs where an incorrect bow was displayed when it broke (#70859,#93972,#93974)
 		if (useItem->count == 0)
@@ -313,7 +313,7 @@ void Player::tick()
 
 	if (!level->isClientSide)
 	{
-		if (containerMenu != NULL && !containerMenu->stillValid( dynamic_pointer_cast<Player>( shared_from_this() ) ))
+		if (containerMenu != NULL && !containerMenu->stillValid( std::dynamic_pointer_cast<Player>( shared_from_this() ) ))
 		{
 			closeContainer();
 			containerMenu = inventoryMenu;
@@ -356,7 +356,7 @@ void Player::tick()
 
 	if (!level->isClientSide)
 	{
-		foodData.tick(dynamic_pointer_cast<Player>(shared_from_this()));
+		foodData.tick(std::dynamic_pointer_cast<Player>(shared_from_this()));
 	}
 
 	// 4J Stu Debugging
@@ -412,29 +412,29 @@ void Player::tick()
 			//this->drop( std::shared_ptr<ItemInstance>( new ItemInstance( Tile::fence, 64 ) ) );
 
 
-			//std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(Pig::_class->newInstance( level ));
+			//std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(Pig::_class->newInstance( level ));
 			//mob->moveTo(x+1, y, z+1, level->random->nextFloat() * 360, 0);
 			//level->addEntity(mob);
 
 			// 4J : WESTY : Spawn some wolves to befriend!
 			/*
-			std::shared_ptr<Mob> mob1 = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
+			std::shared_ptr<Mob> mob1 = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
 			mob1->moveTo(x+1, y, z+1, level->random->nextFloat() * 360, 0);
 			level->addEntity(mob1);
 
-			std::shared_ptr<Mob> mob2 = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
+			std::shared_ptr<Mob> mob2 = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
 			mob2->moveTo(x+2, y, z+1, level->random->nextFloat() * 360, 0);
 			level->addEntity(mob2);
 
-			std::shared_ptr<Mob> mob3 = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
+			std::shared_ptr<Mob> mob3 = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
 			mob3->moveTo(x+1, y, z+2, level->random->nextFloat() * 360, 0);
 			level->addEntity(mob3);
 
-			std::shared_ptr<Mob> mob4 = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
+			std::shared_ptr<Mob> mob4 = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
 			mob4->moveTo(x+3, y, z+1, level->random->nextFloat() * 360, 0);
 			level->addEntity(mob4);
 
-			std::shared_ptr<Mob> mob5 = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
+			std::shared_ptr<Mob> mob5 = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
 			mob5->moveTo(x+1, y, z+3, level->random->nextFloat() * 360, 0);
 			level->addEntity(mob5);
 			*/
@@ -559,7 +559,7 @@ void Player::completeUsingItem()
 		spawnEatParticles(useItem, 16);
 
 		int oldCount = useItem->count;
-		std::shared_ptr<ItemInstance> itemInstance = useItem->useTimeDepleted(level, dynamic_pointer_cast<Player>(shared_from_this()));
+		std::shared_ptr<ItemInstance> itemInstance = useItem->useTimeDepleted(level, std::dynamic_pointer_cast<Player>(shared_from_this()));
 		if (itemInstance != useItem || (itemInstance != NULL && itemInstance->count != oldCount))
 		{
 			inventory->items[inventory->selected] = itemInstance;
@@ -944,7 +944,7 @@ void Player::rideTick()
 		//xRot = preXRot;
 		//yRot = preYRot;
 
-		std::shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(riding);
+		std::shared_ptr<Pig> pig = std::dynamic_pointer_cast<Pig>(riding);
 		yBodyRot = pig->yBodyRot;
 
 		while (yBodyRot - yBodyRotO < -180)
@@ -1057,7 +1057,7 @@ void Player::aiStep()
 
 void Player::touch(std::shared_ptr<Entity> entity)
 {
-	entity->playerTouch( dynamic_pointer_cast<Player>( shared_from_this() ) );
+	entity->playerTouch( std::dynamic_pointer_cast<Player>( shared_from_this() ) );
 }
 
 // 4J - Removed 1.0.1
@@ -1351,17 +1351,17 @@ bool Player::hurt(DamageSource *source, int dmg)
 	if (dmg == 0) return false;
 
 	std::shared_ptr<Entity> attacker = source->getEntity();
-	if ( dynamic_pointer_cast<Arrow>( attacker ) != NULL )
+	if ( std::dynamic_pointer_cast<Arrow>( attacker ) != NULL )
 	{
-		if ((dynamic_pointer_cast<Arrow>(attacker))->owner != NULL)
+		if ((std::dynamic_pointer_cast<Arrow>(attacker))->owner != NULL)
 		{
-			attacker = (dynamic_pointer_cast<Arrow>(attacker))->owner;
+			attacker = (std::dynamic_pointer_cast<Arrow>(attacker))->owner;
 		}
 	}
-	if ( dynamic_pointer_cast<Mob>( attacker ) != NULL )
+	if ( std::dynamic_pointer_cast<Mob>( attacker ) != NULL )
 	{
 		// aggreviate all pet wolves nearby
-		directAllTameWolvesOnTarget(dynamic_pointer_cast<Mob>(attacker), false);
+		directAllTameWolvesOnTarget(std::dynamic_pointer_cast<Mob>(attacker), false);
 	}
 
 	return this->Mob::hurt(source, dmg);
@@ -1400,20 +1400,20 @@ void Player::directAllTameWolvesOnTarget(std::shared_ptr<Mob> target, bool skipS
 {
 
 	// filter un-attackable mobs
-	if ((dynamic_pointer_cast<Creeper>( target ) != NULL) || (dynamic_pointer_cast<Ghast>( target) != NULL))
+	if ((std::dynamic_pointer_cast<Creeper>( target ) != NULL) || (std::dynamic_pointer_cast<Ghast>( target) != NULL))
 	{
 		return;
 	}
 	// never target wolves that has this player as owner
-	if (dynamic_pointer_cast<Wolf>(target) != NULL)
+	if (std::dynamic_pointer_cast<Wolf>(target) != NULL)
 	{
-		std::shared_ptr<Wolf> wolfTarget = dynamic_pointer_cast<Wolf>(target);
+		std::shared_ptr<Wolf> wolfTarget = std::dynamic_pointer_cast<Wolf>(target);
 		if (wolfTarget->isTame() && m_UUID.compare( wolfTarget->getOwnerUUID() ) == 0 )
 		{
 			return;
 		}
 	}
-	if ((dynamic_pointer_cast<Player>( target ) != NULL) && !isPlayerVersusPlayer())
+	if ((std::dynamic_pointer_cast<Player>( target ) != NULL) && !isPlayerVersusPlayer())
 	{
 		// pvp is off
 		return;
@@ -1425,7 +1425,7 @@ void Player::directAllTameWolvesOnTarget(std::shared_ptr<Mob> target, bool skipS
 	AUTO_VAR(itEnd, nearbyWolves->end());
 	for (AUTO_VAR(it, nearbyWolves->begin()); it != itEnd; it++)
 	{
-		std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(*it);;
+		std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(*it);;
 		if (wolf->isTame() && wolf->getAttackTarget() == NULL && m_UUID.compare( wolf->getOwnerUUID() ) == 0)
 		{
 			if (!skipSitting || !wolf->isSitting())
@@ -1510,15 +1510,15 @@ void Player::openItemInstanceGui(std::shared_ptr<ItemInstance> itemInstance)
 
 bool Player::interact(std::shared_ptr<Entity> entity)
 {
-	if (entity->interact( dynamic_pointer_cast<Player>( shared_from_this() ) )) return true;
+	if (entity->interact( std::dynamic_pointer_cast<Player>( shared_from_this() ) )) return true;
 	std::shared_ptr<ItemInstance> item = getSelectedItem();
-	if (item != NULL && dynamic_pointer_cast<Mob>( entity ) != NULL)
+	if (item != NULL && std::dynamic_pointer_cast<Mob>( entity ) != NULL)
 	{		
 		// 4J - PC Comments
 		// Hack to prevent item stacks from decrementing if the player has
 		// the ability to instabuild
 		if(this->abilities.instabuild) item = item->copy();
-		if(item->interactEnemy(dynamic_pointer_cast<Mob>(entity)))
+		if(item->interactEnemy(std::dynamic_pointer_cast<Mob>(entity)))
 		{
 			// 4J - PC Comments
 			// Don't remove the item in hand if the player has the ability
@@ -1578,7 +1578,7 @@ void Player::attack(std::shared_ptr<Entity> entity)
 
 	int knockback = 0;
 	int magicBoost = 0;
-	std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(entity);
+	std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(entity);
 	if (mob != NULL)
 	{
 		magicBoost = EnchantmentHelper::getDamageBonus(inventory, mob);
@@ -1601,14 +1601,14 @@ void Player::attack(std::shared_ptr<Entity> entity)
 		// Ensure we put the entity on fire if we're hitting with a
 		// fire-enchanted weapon
 		bool setOnFireTemporatily = false;
-		int fireAspect = EnchantmentHelper::getFireAspect(dynamic_pointer_cast<Mob>(shared_from_this()));
-		if (dynamic_pointer_cast<Mob>(entity) && fireAspect > 0 && !entity->isOnFire())
+		int fireAspect = EnchantmentHelper::getFireAspect(std::dynamic_pointer_cast<Mob>(shared_from_this()));
+		if (std::dynamic_pointer_cast<Mob>(entity) && fireAspect > 0 && !entity->isOnFire())
 		{
 			setOnFireTemporatily = true;
 			entity->setOnFire(1);
 		}
 
-		DamageSource *damageSource = DamageSource::playerAttack(dynamic_pointer_cast<Player>(shared_from_this()));
+		DamageSource *damageSource = DamageSource::playerAttack(std::dynamic_pointer_cast<Player>(shared_from_this()));
 		bool wasHurt = entity->hurt(damageSource, dmg);
 		delete damageSource;
 		if (wasHurt)
@@ -1636,7 +1636,7 @@ void Player::attack(std::shared_ptr<Entity> entity)
 			}
 			setLastHurtMob(entity);
 
-			std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(entity);
+			std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(entity);
 			if (mob)
 			{
 				ThornsEnchantment::doThornsAfterAttack(shared_from_this(), mob, random);
@@ -1644,19 +1644,19 @@ void Player::attack(std::shared_ptr<Entity> entity)
 		}
 
 		std::shared_ptr<ItemInstance> item = getSelectedItem();
-		if (item != NULL && dynamic_pointer_cast<Mob>( entity ) != NULL)
+		if (item != NULL && std::dynamic_pointer_cast<Mob>( entity ) != NULL)
 		{
-			item->hurtEnemy(dynamic_pointer_cast<Mob>(entity), dynamic_pointer_cast<Player>( shared_from_this() ) );
+			item->hurtEnemy(std::dynamic_pointer_cast<Mob>(entity), std::dynamic_pointer_cast<Player>( shared_from_this() ) );
 			if (item->count <= 0)
 			{
 				removeSelectedItem();
 			}
 		}
-		if (dynamic_pointer_cast<Mob>( entity ) != NULL)
+		if (std::dynamic_pointer_cast<Mob>( entity ) != NULL)
 		{
 			if (entity->isAlive())
 			{
-				directAllTameWolvesOnTarget(dynamic_pointer_cast<Mob>(entity), true);
+				directAllTameWolvesOnTarget(std::dynamic_pointer_cast<Mob>(entity), true);
 			}
 			// 4J Stu - Brought forward wasHurt check to Fix 66140 - Bug: Fire Aspect bypasses "Player v Player" being Disabled
 			if (fireAspect > 0 && wasHurt)
@@ -1709,10 +1709,10 @@ Slot *Player::getInventorySlot(int slotId)
 void Player::remove()
 {
 	this->Mob::remove();
-	inventoryMenu->removed( dynamic_pointer_cast<Player>( shared_from_this() ) );
+	inventoryMenu->removed( std::dynamic_pointer_cast<Player>( shared_from_this() ) );
 	if (containerMenu != NULL)
 	{
-		containerMenu->removed( dynamic_pointer_cast<Player>( shared_from_this() ) );
+		containerMenu->removed( std::dynamic_pointer_cast<Player>( shared_from_this() ) );
 	}
 }
 
@@ -2143,7 +2143,7 @@ void Player::checkRidingStatistiscs(double dx, double dy, double dz)
 		int distance = (int) Math::round(sqrt(dx * dx + dy * dy + dz * dz) * 100.0f);
 		if (distance > 0)
 		{
-			if ( dynamic_pointer_cast<Minecart>( riding ) )
+			if ( std::dynamic_pointer_cast<Minecart>( riding ) )
 			{
 				distanceMinecart += distance;
 				if( distanceMinecart >= 100 )
@@ -2190,7 +2190,7 @@ void Player::checkRidingStatistiscs(double dx, double dy, double dz)
 				}
 
 			}
-			else if (dynamic_pointer_cast<Boat>( riding ) != NULL)
+			else if (std::dynamic_pointer_cast<Boat>( riding ) != NULL)
 			{
 				distanceBoat += distance;
 				if( distanceBoat >= 100 )
@@ -2200,7 +2200,7 @@ void Player::checkRidingStatistiscs(double dx, double dy, double dz)
 					awardStat(GenericStats::boatOneM(), GenericStats::param_boat(newDistance/100) );
 				}
 			}
-			else if (dynamic_pointer_cast<Pig>( riding ) != NULL)
+			else if (std::dynamic_pointer_cast<Pig>( riding ) != NULL)
 			{
 				distancePig += distance;
 				if( distancePig >= 100 )
@@ -2236,7 +2236,7 @@ void Player::causeFallDamage(float distance)
 void Player::killed(std::shared_ptr<Mob> mob)
 {
 	// 4J-PB - added the lavaslime enemy - fix for #64007 - TU7: Code: Achievements: TCR#073: Killing Magma Cubes doesn't unlock "Monster Hunter" Achievement.
-	if( dynamic_pointer_cast<Monster>( mob ) != NULL || mob->GetType() == eTYPE_GHAST || mob->GetType() == eTYPE_SLIME || mob->GetType() == eTYPE_LAVASLIME || mob->GetType() == eTYPE_ENDERDRAGON)
+	if( std::dynamic_pointer_cast<Monster>( mob ) != NULL || mob->GetType() == eTYPE_GHAST || mob->GetType() == eTYPE_SLIME || mob->GetType() == eTYPE_LAVASLIME || mob->GetType() == eTYPE_ENDERDRAGON)
 	{
 		awardStat(GenericStats::killEnemy(), GenericStats::param_noArgs());
 
@@ -2426,7 +2426,7 @@ void Player::startUsingItem(std::shared_ptr<ItemInstance> instance, int duration
 
 	// 4J-JEV, hook for ItemUsed event, and ironbelly achievement.
 	awardStat(GenericStats::itemsUsed(instance->getItem()->id),
-		GenericStats::param_itemsUsed(dynamic_pointer_cast<Player>(shared_from_this()),instance));
+		GenericStats::param_itemsUsed(std::dynamic_pointer_cast<Player>(shared_from_this()),instance));
 
 #if (!defined _DURANGO) && (defined _EXTENDED_ACHIEVEMENTS)
 	if ( (instance->getItem()->id == Item::rotten_flesh_Id) && (getFoodData()->getFoodLevel() == 0) )
@@ -2775,7 +2775,7 @@ bool Player::isAllowedToInteract(std::shared_ptr<Entity> target)
 		{
 			if (getPlayerGamePrivilege(Player::ePlayerGamePrivilege_CanUseContainers) == 0)
 			{
-				std::shared_ptr<Minecart> minecart = dynamic_pointer_cast<Minecart>( target );
+				std::shared_ptr<Minecart> minecart = std::dynamic_pointer_cast<Minecart>( target );
 				if (minecart->type == Minecart::CHEST)
 					allowed = false;
 			}
diff --git a/Minecraft.World/WorldGen/Features/BonusChestFeature.cpp b/Minecraft.World/WorldGen/Features/BonusChestFeature.cpp
index 11e3f18bb..ebcd35306 100644
--- a/Minecraft.World/WorldGen/Features/BonusChestFeature.cpp
+++ b/Minecraft.World/WorldGen/Features/BonusChestFeature.cpp
@@ -58,7 +58,7 @@ bool BonusChestFeature::place(Level *level, Random *random, int x, int y, int z,
         if (force || ( level->isEmptyTile(x2, y2, z2) && level->isTopSolidBlocking(x2, y2 - 1, z2)))
 		{
             level->setTile(x2, y2, z2, Tile::chest_Id);
-            std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x2, y2, z2));
+            std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x2, y2, z2));
             if (chest != NULL)
 			{
                 WeighedTreasure::addChestItems(random, treasureList, chest, numRolls);
diff --git a/Minecraft.World/WorldGen/Features/MonsterRoomFeature.cpp b/Minecraft.World/WorldGen/Features/MonsterRoomFeature.cpp
index 44e68f1b1..b1ccd5aef 100644
--- a/Minecraft.World/WorldGen/Features/MonsterRoomFeature.cpp
+++ b/Minecraft.World/WorldGen/Features/MonsterRoomFeature.cpp
@@ -84,7 +84,7 @@ bool MonsterRoomFeature::place(Level *level, Random *random, int x, int y, int z
 			if (count != 1) continue;
 
 			level->setTile(xc, yc, zc, Tile::chest_Id);
-			std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity >( level->getTileEntity(xc, yc, zc) );
+			std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity >( level->getTileEntity(xc, yc, zc) );
 			if (chest != NULL )
 			{
 				for (int j = 0; j < 8; j++)
@@ -100,7 +100,7 @@ bool MonsterRoomFeature::place(Level *level, Random *random, int x, int y, int z
 
 
 	level->setTile(x, y, z, Tile::mobSpawner_Id);
-	std::shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, z) );
+	std::shared_ptr<MobSpawnerTileEntity> entity = std::dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, z) );
 	if( entity != NULL )
 	{
 		entity->setEntityId(randomEntityId(random));
diff --git a/Minecraft.World/WorldGen/Structures/MineShaftPieces.cpp b/Minecraft.World/WorldGen/Structures/MineShaftPieces.cpp
index 6b82919c4..0855bebe3 100644
--- a/Minecraft.World/WorldGen/Structures/MineShaftPieces.cpp
+++ b/Minecraft.World/WorldGen/Structures/MineShaftPieces.cpp
@@ -440,7 +440,7 @@ bool MineShaftPieces::MineShaftCorridor::postProcess(Level *level, Random *rando
 			{
 				hasPlacedSpider = true;
 				level->setTile(x, y, newZ, Tile::mobSpawner_Id);
-				std::shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, newZ) );
+				std::shared_ptr<MobSpawnerTileEntity> entity = std::dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, newZ) );
 				if (entity != NULL) entity->setEntityId(L"CaveSpider");
 			}
 		}
diff --git a/Minecraft.World/WorldGen/Structures/NetherBridgePieces.cpp b/Minecraft.World/WorldGen/Structures/NetherBridgePieces.cpp
index 9011a824c..029d22880 100644
--- a/Minecraft.World/WorldGen/Structures/NetherBridgePieces.cpp
+++ b/Minecraft.World/WorldGen/Structures/NetherBridgePieces.cpp
@@ -757,7 +757,7 @@ bool NetherBridgePieces::MonsterThrone::postProcess(Level *level, Random *random
 		{
 			hasPlacedMobSpawner = true;
 			level->setTile(x, y, z, Tile::mobSpawner_Id);
-			std::shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, z) );
+			std::shared_ptr<MobSpawnerTileEntity> entity = std::dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, z) );
 			if (entity != NULL) entity->setEntityId(L"Blaze");
 		}
 	}
diff --git a/Minecraft.World/WorldGen/Structures/StrongholdPieces.cpp b/Minecraft.World/WorldGen/Structures/StrongholdPieces.cpp
index 033b206c1..bd8af08c6 100644
--- a/Minecraft.World/WorldGen/Structures/StrongholdPieces.cpp
+++ b/Minecraft.World/WorldGen/Structures/StrongholdPieces.cpp
@@ -1473,7 +1473,7 @@ bool StrongholdPieces::PortalRoom::postProcess(Level *level, Random *random, Bou
 
 			hasPlacedMobSpawner = true;
 			level->setTile(x, y, z, Tile::mobSpawner_Id);
-			std::shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>(level->getTileEntity(x, y, z));
+			std::shared_ptr<MobSpawnerTileEntity> entity = std::dynamic_pointer_cast<MobSpawnerTileEntity>(level->getTileEntity(x, y, z));
 			if (entity != NULL) entity->setEntityId(L"Silverfish");
 		}
 	}
diff --git a/Minecraft.World/WorldGen/Structures/StructurePiece.cpp b/Minecraft.World/WorldGen/Structures/StructurePiece.cpp
index 724e5f401..4312d7cb0 100644
--- a/Minecraft.World/WorldGen/Structures/StructurePiece.cpp
+++ b/Minecraft.World/WorldGen/Structures/StructurePiece.cpp
@@ -781,7 +781,7 @@ bool StructurePiece::createChest( Level* level, BoundingBox* chunkBB, Random* ra
 		if ( level->getTile( worldX, worldY, worldZ ) != Tile::chest->id )
 		{
 			level->setTile( worldX, worldY, worldZ, Tile::chest->id );
-			std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity( worldX, worldY, worldZ ));
+			std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity( worldX, worldY, worldZ ));
 			if ( chest != NULL ) WeighedTreasure::addChestItems( random, treasure, chest, numRolls );
 			return true;
 		}
@@ -800,7 +800,7 @@ bool StructurePiece::createDispenser(Level *level, BoundingBox *chunkBB, Random
 		if (level->getTile(worldX, worldY, worldZ) != Tile::dispenser_Id)
 		{
 			level->setTileAndData(worldX, worldY, worldZ, Tile::dispenser_Id, getOrientationData(Tile::dispenser_Id, facing));
-			std::shared_ptr<DispenserTileEntity> dispenser = dynamic_pointer_cast<DispenserTileEntity>(level->getTileEntity(worldX, worldY, worldZ));
+			std::shared_ptr<DispenserTileEntity> dispenser = std::dynamic_pointer_cast<DispenserTileEntity>(level->getTileEntity(worldX, worldY, worldZ));
 			if (dispenser != NULL) WeighedTreasure::addDispenserItems(random, items, dispenser, numRolls);
 			return true;
 		}