backups/4jcraft
2
0
Fork 0
mirror of https://github.com/4jcraft/4jcraft.git synced 2026-10-22 19:22:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor: unglob std::dynamic_pointer_cast

Browse source
This commit is contained in:
Tropical 2026-03-06 22:13:29 -06:00 committed by JuiceyDev
parent 39a359ca56
commit 66248339e5
204 changed files with 603 additions and 603 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
Minecraft.Client/Level/ServerLevel.cpp
View file

@ -671,11 +671,11 @@ void ServerLevel::tick(std::shared_ptr<Entity> e, bool actual)
{ {
e->remove(); e->remove();
} }
if (!server->isNpcsEnabled() && (dynamic_pointer_cast<Npc>(e) != NULL)) if (!server->isNpcsEnabled() && (std::dynamic_pointer_cast<Npc>(e) != NULL))
{ {
e->remove(); 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); Level::tick(e, actual);
} }
@ -814,7 +814,7 @@ void ServerLevel::generateBonusItemsNearSpawn()
if( getTile( x, y, z ) == Tile::chest_Id ) 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 != NULL)
{ {
if( chest->isBonusChest ) 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; std::vector<std::shared_ptr<ServerPlayer> > sentTo;
for(AUTO_VAR(it, players.begin()); it != players.end(); ++it) 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; if (player->dimension != dimension->id) continue;
bool knockbackOnly = false; bool knockbackOnly = false;
@ -1188,7 +1188,7 @@ void ServerLevel::runQueuedSendTileUpdates()
bool ServerLevel::addEntity(std::shared_ptr<Entity> e) bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
{ {
// If its an item entity, and we've got to our capacity, delete the oldest // 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()); // printf("Adding item entity count %d\n",m_itemEntities.size());
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
@ -1200,7 +1200,7 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
// If its an hanging entity, and we've got to our capacity, delete the oldest // 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()); // printf("Adding item entity count %d\n",m_itemEntities.size());
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
@ -1217,7 +1217,7 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
// If its an arrow entity, and we've got to our capacity, delete the oldest // 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()); // printf("Adding arrow entity count %d\n",m_arrowEntities.size());
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
@ -1229,7 +1229,7 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
// If its an experience orb entity, and we've got to our capacity, delete the oldest // 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()); // printf("Adding arrow entity count %d\n",m_arrowEntities.size());
EnterCriticalSection(&m_limiterCS); 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 // Maintain a cound of primed tnt & falling tiles in this level
void ServerLevel::entityAddedExtra(std::shared_ptr<Entity> e) 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); EnterCriticalSection(&m_limiterCS);
m_itemEntities.push_back(e); m_itemEntities.push_back(e);
// printf("entity added: item entity count now %d\n",m_itemEntities.size()); // printf("entity added: item entity count now %d\n",m_itemEntities.size());
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
else if( dynamic_pointer_cast<HangingEntity>(e) != NULL ) else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL )
{ {
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
m_hangingEntities.push_back(e); m_hangingEntities.push_back(e);
// printf("entity added: item entity count now %d\n",m_itemEntities.size()); // printf("entity added: item entity count now %d\n",m_itemEntities.size());
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
else if( dynamic_pointer_cast<Arrow>(e) != NULL ) else if( std::dynamic_pointer_cast<Arrow>(e) != NULL )
{ {
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
m_arrowEntities.push_back(e); m_arrowEntities.push_back(e);
// printf("entity added: arrow entity count now %d\n",m_arrowEntities.size()); // printf("entity added: arrow entity count now %d\n",m_arrowEntities.size());
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL ) else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
{ {
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
m_experienceOrbEntities.push_back(e); m_experienceOrbEntities.push_back(e);
// printf("entity added: experience orb entity count now %d\n",m_arrowEntities.size()); // printf("entity added: experience orb entity count now %d\n",m_arrowEntities.size());
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
else if( dynamic_pointer_cast<PrimedTnt>(e) != NULL ) else if( std::dynamic_pointer_cast<PrimedTnt>(e) != NULL )
{ {
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
m_primedTntCount++; m_primedTntCount++;
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
else if( dynamic_pointer_cast<FallingTile>(e) != NULL ) else if( std::dynamic_pointer_cast<FallingTile>(e) != NULL )
{ {
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
m_fallingTileCount++; 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 // 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) 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); EnterCriticalSection(&m_limiterCS);
// printf("entity removed: item entity count %d\n",m_itemEntities.size()); // 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()); // printf("entity removed: item entity count now %d\n",m_itemEntities.size());
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
else if( dynamic_pointer_cast<HangingEntity>(e) != NULL ) else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL )
{ {
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
// printf("entity removed: item entity count %d\n",m_itemEntities.size()); // 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()); // printf("entity removed: item entity count now %d\n",m_itemEntities.size());
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
else if( dynamic_pointer_cast<Arrow>(e) != NULL ) else if( std::dynamic_pointer_cast<Arrow>(e) != NULL )
{ {
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
// printf("entity removed: arrow entity count %d\n",m_arrowEntities.size()); // 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()); // printf("entity removed: arrow entity count now %d\n",m_arrowEntities.size());
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL ) else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
{ {
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
// printf("entity removed: experience orb entity count %d\n",m_arrowEntities.size()); // 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()); // printf("entity removed: experience orb entity count now %d\n",m_arrowEntities.size());
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
else if( dynamic_pointer_cast<PrimedTnt>(e) != NULL ) else if( std::dynamic_pointer_cast<PrimedTnt>(e) != NULL )
{ {
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
m_primedTntCount--; m_primedTntCount--;
LeaveCriticalSection(&m_limiterCS); LeaveCriticalSection(&m_limiterCS);
} }
else if( dynamic_pointer_cast<FallingTile>(e) != NULL ) else if( std::dynamic_pointer_cast<FallingTile>(e) != NULL )
{ {
EnterCriticalSection(&m_limiterCS); EnterCriticalSection(&m_limiterCS);
m_fallingTileCount--; m_fallingTileCount--;

4
Minecraft.Client/Level/ServerLevelListener.cpp
View file

@ -48,7 +48,7 @@ void ServerLevelListener::entityRemoved(std::shared_ptr<Entity> entity)
// 4J added // 4J added
void ServerLevelListener::playerRemoved(std::shared_ptr<Entity> entity) 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); 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. // 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 // 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))); 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)));
} }
} }

52
Minecraft.Client/Minecraft.cpp
View file

@ -2723,7 +2723,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
{ {
default: 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)) if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
{ {
@ -2752,7 +2752,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break; break;
default: 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)) 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: case Item::shears_Id:
{ {
if(player->isAllowedToAttackAnimals()) *piAction=IDS_TOOLTIPS_HIT; 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; if(!animal->isBaby()) *piUse=IDS_TOOLTIPS_SHEAR;
} }
break; break;
default: 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)) 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; *piAction=IDS_TOOLTIPS_MINE;
// are we in the boat already? // 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; *piUse=IDS_TOOLTIPS_EXIT;
} }
@ -2823,13 +2823,13 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
case eTYPE_MINECART: case eTYPE_MINECART:
*piAction=IDS_TOOLTIPS_MINE; *piAction=IDS_TOOLTIPS_MINE;
// are we in the minecart already? // 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; *piUse=IDS_TOOLTIPS_EXIT;
} }
else else
{ {
switch(dynamic_pointer_cast<Minecart>(hitResult->entity)->type) switch(std::dynamic_pointer_cast<Minecart>(hitResult->entity)->type)
{ {
case Minecart::RIDEABLE: case Minecart::RIDEABLE:
*piUse=IDS_TOOLTIPS_RIDE; *piUse=IDS_TOOLTIPS_RIDE;
@ -2871,7 +2871,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
{ {
case Item::dye_powder_Id: 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) // convert to tile-based color value (0 is white instead of black)
int newColor = ClothTile::getTileDataForItemAuxValue(heldItem->getAuxValue()); int newColor = ClothTile::getTileDataForItemAuxValue(heldItem->getAuxValue());
@ -2884,7 +2884,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break; break;
case Item::shears_Id: 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 // can only shear a sheep that hasn't been sheared
if(!sheep->isSheared() ) if(!sheep->isSheared() )
@ -2896,7 +2896,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break; break;
default: 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)) 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: case eTYPE_PIG:
// can ride a pig // can ride a pig
if(player->isAllowedToAttackAnimals()) *piAction=IDS_TOOLTIPS_HIT; 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; *piUse=IDS_TOOLTIPS_EXIT;
} }
else else
{ {
// does the pig have a saddle? // 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; *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()) if(player->inventory->IsHeldItem())
{ {
@ -2936,7 +2936,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break; break;
default: 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)) 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; int iID=-1;
std::shared_ptr<ItemInstance> heldItem=nullptr; 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()) if(player->inventory->IsHeldItem())
{ {
@ -3045,7 +3045,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
{ {
int iID=-1; int iID=-1;
std::shared_ptr<ItemInstance> heldItem=nullptr; 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()) if(player->inventory->IsHeldItem())
{ {
@ -3106,7 +3106,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
case eTYPE_PLAYER: case eTYPE_PLAYER:
{ {
// Fix for #58576 - TU6: Content: Gameplay: Hit button prompt is available when attacking a host who has "Invisible" option turned on // 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 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; break;
case eTYPE_ITEM_FRAME: 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? // is the frame occupied?
if(itemFrame->getItem()!=NULL) if(itemFrame->getItem()!=NULL)
@ -3141,7 +3141,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break; break;
case eTYPE_VILLAGER: 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()) if (!villager->isBaby())
{ {
*piUse=IDS_TOOLTIPS_TRADE; *piUse=IDS_TOOLTIPS_TRADE;
@ -3151,7 +3151,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break; break;
case eTYPE_ZOMBIE: 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; std::shared_ptr<ItemInstance> heldItem=nullptr;
if(player->inventory->IsHeldItem()) 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()) 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 = std::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 = std::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>(std::shared_ptr<Spider>(new Spider( level )));
mob->moveTo(player->x+1, player->y, player->z+1, level->random->nextFloat() * 360, 0); mob->moveTo(player->x+1, player->y, player->z+1, level->random->nextFloat() * 360, 0);
level->addEntity(mob); 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)) 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); ui.PlayUISFX(eSFX_Press);
app.LoadInventoryMenu(iPad,player); app.LoadInventoryMenu(iPad,player);
} }
if((player->ullButtonsPressed&(1LL<<MINECRAFT_ACTION_CRAFTING)) && gameMode->isInputAllowed(MINECRAFT_ACTION_CRAFTING)) 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 // 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 // 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)) 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(); if(mplp) mplp->StopSleeping();

2
Minecraft.Client/MinecraftServer.cpp
View file

@ -1291,7 +1291,7 @@ void MinecraftServer::run(__int64 seed, void *lpParameter)
{ {
std::shared_ptr<ServerPlayer> player = players->players.at(0); std::shared_ptr<ServerPlayer> player = players->players.at(0);
eINSTANCEOF factory = (eINSTANCEOF)((size_t)param); 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->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) mob->setDespawnProtected(); // 4J added, default to being protected against despawning (has to be done after initial position is set)
player->level->addEntity(mob); player->level->addEntity(mob);

54
Minecraft.Client/Network/ClientConnection.cpp
View file

@ -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) if (player != NULL)
{ {
std::shared_ptr<FishingHook> hook = std::shared_ptr<FishingHook>( new FishingHook(level, x, y, z, player) ); 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) if (player != NULL)
{ {
std::shared_ptr<FishingHook> hook = std::shared_ptr<FishingHook>( new FishingHook(level, x, y, z, player) ); 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) void ClientConnection::handleTakeItemEntity(std::shared_ptr<TakeItemEntityPacket> packet)
{ {
std::shared_ptr<Entity> from = getEntity(packet->itemId); 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 // 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 // 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 // "from" reference if we've already removed the item for an earlier processed connection
if( isLocalPlayer ) 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. // 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 // 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 (e == NULL) return;
if (packet->action == AnimatePacket::SWING) 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(); if(player != NULL) player->swing();
} }
else if (packet->action == AnimatePacket::HURT) 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) 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); if(player != NULL) player->stopSleepInBed(false, false, false);
} }
else if (packet->action == AnimatePacket::RESPAWN) else if (packet->action == AnimatePacket::RESPAWN)
@ -1592,7 +1592,7 @@ void ClientConnection::handleAnimate(std::shared_ptr<AnimatePacket> packet)
critParticle->CritParticlePostConstructor(); critParticle->CritParticlePostConstructor();
minecraft->particleEngine->add(critParticle); 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 (e == NULL) return;
if (packet->action == EntityActionAtPositionPacket::START_SLEEP) 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); player->startSleepInBed(packet->x, packet->y, packet->z);
if( player == minecraft->localplayers[m_userIndex] ) 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 yRot = packet->yRot * 360 / 256.0f;
float xRot = packet->xRot * 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->xp = packet->x;
mob->yp = packet->y; mob->yp = packet->y;
mob->zp = packet->z; 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 // 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) 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() ); 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> rider = getEntity(packet->riderId);
std::shared_ptr<Entity> ridden = getEntity(packet->riddenId); 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->player->entityId) rider = minecraft->player;
if (packet->riderId == minecraft->localplayers[m_userIndex]->entityId) 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); std::shared_ptr<Entity> e = getEntity(packet->id);
if (e == NULL) return; 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; if( e == NULL) return;
bool isLocalPlayer = false; bool isLocalPlayer = false;
@ -2379,7 +2379,7 @@ void ClientConnection::handleTextureAndGeometryChange(std::shared_ptr<TextureAnd
{ {
std::shared_ptr<Entity> e = getEntity(packet->id); std::shared_ptr<Entity> e = getEntity(packet->id);
if (e == NULL) return; 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; if( e == NULL) return;
bool isLocalPlayer = false; 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); std::shared_ptr<TileEntity> te = minecraft->level->getTileEntity(packet->x, packet->y, packet->z);
// 4J-PB - on a client connecting, the line below fails // 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++) for (int i = 0; i < MAX_SIGN_LINES; i++)
{ {
ste->SetMessage(i,packet->lines[i]); ste->SetMessage(i,packet->lines[i]);
@ -2778,7 +2778,7 @@ void ClientConnection::handleSignUpdate(std::shared_ptr<SignUpdatePacket> packet
} }
else else
{ {
app.DebugPrintf("dynamic_pointer_cast<SignTileEntity>(te) == NULL\n"); app.DebugPrintf("std::dynamic_pointer_cast<SignTileEntity>(te) == NULL\n");
} }
} }
else else
@ -2795,9 +2795,9 @@ void ClientConnection::handleTileEntityData(std::shared_ptr<TileEntityDataPacket
if (te != NULL) 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)) //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); // ((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) void ClientConnection::handleUpdateMobEffect(std::shared_ptr<UpdateMobEffectPacket> packet)
{ {
std::shared_ptr<Entity> e = getEntity(packet->entityId); 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) void ClientConnection::handleRemoveMobEffect(std::shared_ptr<RemoveMobEffectPacket> packet)
{ {
std::shared_ptr<Entity> e = getEntity(packet->entityId); 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() bool ClientConnection::isServerPacketListener()
@ -3005,7 +3005,7 @@ void ClientConnection::handlePlayerInfo(std::shared_ptr<PlayerInfoPacket> packet
std::shared_ptr<Entity> entity = getEntity(packet->m_entityId); std::shared_ptr<Entity> entity = getEntity(packet->m_entityId);
if(entity != NULL && entity->GetType() == eTYPE_PLAYER) 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); player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_All, packet->m_playerPrivileges);
} }
if(networkPlayer != NULL && networkPlayer->IsLocal()) if(networkPlayer != NULL && networkPlayer->IsLocal())

14
Minecraft.Client/Network/PlayerConnection.cpp
View file

@ -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); 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()) if (!ste->isEditable())
{ {
server->warn(L"Player " + player->name + L" just tried to change non-editable sign"); 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 []. // 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 x = packet->x;
int y = packet->y; int y = packet->y;
int z = packet->z; 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++) for (int i = 0; i < 4; i++)
{ {
std::wstring lineText = packet->lines[i].substr(0,15); 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) 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); 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))) 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 ) if(player->inventory->add(pTempItemInst)==false )
{ {
// no room in inventory, so throw it down // 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... // TODO 4J Stu - Assume at the moment that the client can work this out for us...
//if(pRecipeIngredientsRequired[iRecipe].bCanMake) //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 // and remove those resources from your inventory
for(int i=0;i<pRecipeIngredientsRequired[iRecipe].iIngC;i++) for(int i=0;i<pRecipeIngredientsRequired[iRecipe].iIngC;i++)

4
Minecraft.Client/Network/PlayerList.cpp
View file

@ -1037,7 +1037,7 @@ void PlayerList::broadcast(std::shared_ptr<Player> except, double x, double y, d
std::vector< std::shared_ptr<ServerPlayer> > sentTo; std::vector< std::shared_ptr<ServerPlayer> > sentTo;
if( except != NULL ) 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++) 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 (xd * xd + yd * yd + zd * zd < range * range)
{ {
#if 0 // _DEBUG #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) if(SoundPacket)
{ {

2
Minecraft.Client/Platform/PS3/PS3Extras/Ps3Types.h
View file

@ -22,7 +22,7 @@
using std::tr1::bad_std::; using std::tr1::bad_std::;
using std::tr1::const_pointer_cast; 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::enable_shared_from_this;
using std::tr1::get_deleter; using std::tr1::get_deleter;
using std::tr1::std::shared_ptr; using std::tr1::std::shared_ptr;

2
Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/detail/intersegment_ptr.hpp
View file

@ -886,7 +886,7 @@ boost::interprocess::intersegment_ptr<T> const_pointer_cast(const boost::interpr
//!Simulation of dynamic_cast between pointers. //!Simulation of dynamic_cast between pointers.
//!Never throws. //!Never throws.
template<class T, class U> inline 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()); } { return boost::interprocess::intersegment_ptr<T>(r, boost::interprocess::ipcdetail::dynamic_cast_tag()); }
//!Simulation of reinterpret_cast between pointers. //!Simulation of reinterpret_cast between pointers.

2
Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/offset_ptr.hpp
View file

@ -602,7 +602,7 @@ inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
//!Simulation of dynamic_cast between pointers. Never throws. //!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> 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> 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> return boost::interprocess::offset_ptr<T1, P1, O1, A1>
(r, boost::interprocess::ipcdetail::dynamic_cast_tag()); (r, boost::interprocess::ipcdetail::dynamic_cast_tag());

2
Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/smart_ptr/intrusive_ptr.hpp
View file

@ -262,7 +262,7 @@ inline boost::interprocess::intrusive_ptr<T, VP> const_pointer_cast
/*Emulates dynamic cast operator. Does not throw*/ /*Emulates dynamic cast operator. Does not throw*/
/* /*
template<class T, class U, class VP> 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) (boost::interprocess::intrusive_ptr<U, VP> const & p)
{ return do_dynamic_cast<U>(p.get()); } { return do_dynamic_cast<U>(p.get()); }
*/ */

2
Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/interprocess/smart_ptr/shared_ptr.hpp
View file

@ -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()); } { return shared_ptr<T, VoidAllocator, Deleter>(r, ipcdetail::const_cast_tag()); }
template<class T, class VoidAllocator, class Deleter, class U> inline 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()); } { return shared_ptr<T, VoidAllocator, Deleter>(r, ipcdetail::dynamic_cast_tag()); }
// to_raw_pointer() enables boost::mem_fn to recognize shared_ptr // to_raw_pointer() enables boost::mem_fn to recognize shared_ptr

4
Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/pointer_cast.hpp
View file

@ -19,9 +19,9 @@ inline T* static_pointer_cast(U *ptr)
return static_cast<T*>(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> 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); return dynamic_cast<T*>(ptr);
} }

2
Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/serialization/detail/shared_ptr_132.hpp
View file

@ -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()); 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()); return shared_ptr< T >(r, detail::dynamic_cast_tag());
} }

2
Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/smart_ptr/intrusive_ptr.hpp
View file

@ -270,7 +270,7 @@ template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U>
return const_cast<T *>(p.get()); 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()); return dynamic_cast<T *>(p.get());
} }

2
Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/smart_ptr/shared_ptr.hpp
View file

@ -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 ); 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 //(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

4
Minecraft.Client/Platform/PS3/PS3Extras/boost_1_53_0/boost/tr1/memory.hpp
View file

@ -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(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> 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> 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 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 D, class T> D * get_deleter(shared_ptr<T> const & p) BOOST_NOEXCEPT;
template<class T> class enable_shared_from_this; template<class T> class enable_shared_from_this;
@ -46,7 +46,7 @@ namespace std{ namespace tr1{
using ::boost::swap; using ::boost::swap;
#endif #endif
using ::boost::static_pointer_cast; using ::boost::static_pointer_cast;
using ::boost::dynamic_pointer_cast; using ::boost::std::dynamic_pointer_cast;
using ::boost::const_pointer_cast; using ::boost::const_pointer_cast;
using ::boost::get_deleter; using ::boost::get_deleter;
using ::boost::weak_ptr; using ::boost::weak_ptr;

10
Minecraft.Client/Player/EntityTracker.cpp
View file

@ -31,7 +31,7 @@ void EntityTracker::addEntity(std::shared_ptr<Entity> e)
if (e->GetType() == eTYPE_SERVERPLAYER) if (e->GetType() == eTYPE_SERVERPLAYER)
{ {
addEntity(e, 32 * 16, 2); 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++ ) for( AUTO_VAR(it, entities.begin()); it != entities.end(); it++ )
{ {
if( (*it)->e != player ) 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_MINECART) addEntity(e, 16 * 5, 3, true);
else if (e->GetType() == eTYPE_BOAT) 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 (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_ENDERDRAGON ) addEntity(e, 16 * 10, 3, true);
else if (e->GetType() == eTYPE_PRIMEDTNT) addEntity(e, 16 * 10, 10, 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); 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) 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++ ) for( AUTO_VAR(it, entities.begin()); it != entities.end(); it++ )
{ {
(*it)->removePlayer(player); (*it)->removePlayer(player);
@ -122,7 +122,7 @@ void EntityTracker::tick()
te->tick(this, &level->players); te->tick(this, &level->players);
if (te->moved && te->e->GetType() == eTYPE_SERVERPLAYER) 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 // 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) 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()) if(!player->isAlive())
{ {
player->flushEntitiesToRemove(); player->flushEntitiesToRemove();

14
Minecraft.Client/Player/LocalPlayer.cpp
View file

@ -276,7 +276,7 @@ void LocalPlayer::aiStep()
float runTreshold = 0.8f; float runTreshold = 0.8f;
bool wasRunning = input->ya >= runTreshold; 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 // 4J-PB - make it a localplayer
input->tick( this ); input->tick( this );
if (isUsingItem()) if (isUsingItem())
@ -600,7 +600,7 @@ bool LocalPlayer::openContainer(std::shared_ptr<Container> container)
bool LocalPlayer::startCrafting(int x, int y, int z) 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); if( success ) ui.PlayUISFX(eSFX_Press);
//app.LoadXuiCraftMenu(0,inventory, level, x, y, z); //app.LoadXuiCraftMenu(0,inventory, level, x, y, z);
//minecraft->setScreen(new CraftingScreen(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() && 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; delete [] param.data;
#else #else
@ -1408,7 +1408,7 @@ bool LocalPlayer::handleMouseClick(int button)
if(lastClickState == lastClick_oldRepeat) return false; 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(); if(mplp && mplp->connection) mplp->StopSleeping();
@ -1528,15 +1528,15 @@ void LocalPlayer::updateRichPresence()
{ {
app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_MAP); 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); 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); 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); app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_RIDING_PIG);
} }

4
Minecraft.Client/Player/MultiPlayerLocalPlayer.cpp
View file

@ -334,9 +334,9 @@ void MultiplayerLocalPlayer::ride(std::shared_ptr<Entity> e)
} }
else if (!wasRiding && isRiding) 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); 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); gameMode->getTutorial()->changeTutorialState(e_Tutorial_State_Riding_Boat);
} }
} }

30
Minecraft.Client/Player/ServerPlayer.cpp
View file

@ -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. // 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) 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) if (packet != NULL)
{ {
connection->send(packet); connection->send(packet);
@ -474,7 +474,7 @@ void ServerPlayer::doTickB(bool ignorePortal)
// { // {
// if(level->dimension->id == 0 ) // 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()); // unsigned int uiVal=app.GetGameSettingsDebugMask(ProfileManager.GetPrimaryPad());
// app.SetGameSettingsDebugMask(ProfileManager.GetPrimaryPad(),uiVal&~(1L<<eDebugSetting_GoToEnd)); // app.SetGameSettingsDebugMask(ProfileManager.GetPrimaryPad(),uiVal&~(1L<<eDebugSetting_GoToEnd));
@ -519,7 +519,7 @@ void ServerPlayer::doTickB(bool ignorePortal)
if (dimension == -1) targetDimension = 0; if (dimension == -1) targetDimension = 0;
else targetDimension = -1; 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; lastSentExp = -1;
lastSentHealth = -1; lastSentHealth = -1;
lastSentFood = -1; lastSentFood = -1;
@ -563,7 +563,7 @@ std::shared_ptr<ItemInstance> ServerPlayer::getCarried(int slot)
void ServerPlayer::die(DamageSource *source) 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(); inventory->dropAll();
} }
@ -578,15 +578,15 @@ bool ServerPlayer::hurt(DamageSource *dmgSource, int dmg)
std::shared_ptr<Entity> source = dmgSource->getDirectEntity(); 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; return false;
} }
if (source != NULL && source->GetType() == eTYPE_ARROW) if (source != NULL && source->GetType() == eTYPE_ARROW)
{ {
std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(source); std::shared_ptr<Arrow> arrow = std::dynamic_pointer_cast<Arrow>(source);
if (dynamic_pointer_cast<Player>(arrow->owner) != NULL && (!server->pvp || !dynamic_pointer_cast<Player>(arrow->owner)->isAllowedToAttackPlayers()) ) if (std::dynamic_pointer_cast<Player>(arrow->owner) != NULL && (!server->pvp || !std::dynamic_pointer_cast<Player>(arrow->owner)->isAllowedToAttackPlayers()) )
{ {
return false; return false;
} }
@ -645,9 +645,9 @@ bool ServerPlayer::hurt(DamageSource *dmgSource, int dmg)
m_lastDamageSource = eTelemetryPlayerDeathSource_Explosion_Tnt; m_lastDamageSource = eTelemetryPlayerDeathSource_Explosion_Tnt;
break; break;
case eTYPE_ARROW: 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) if (attacker != NULL)
{ {
switch(attacker->GetType()) switch(attacker->GetType())
@ -725,7 +725,7 @@ void ServerPlayer::changeDimension(int i)
connection->teleport(pos->x, pos->y, pos->z, 0, 0); connection->teleport(pos->x, pos->y, pos->z, 0, 0);
delete pos; 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; lastSentExp = -1;
lastSentHealth = -1; lastSentHealth = -1;
lastSentFood = -1; lastSentFood = -1;
@ -869,7 +869,7 @@ bool ServerPlayer::startRepairing(int x, int y, int z)
{ {
nextContainerCounter(); nextContainerCounter();
connection->send(std::shared_ptr<ContainerOpenPacket> ( new ContainerOpenPacket(containerCounter, ContainerOpenPacket::REPAIR_TABLE, 0, 9)) ); 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->containerId = containerCounter;
containerMenu->addSlotListener(this); 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()))); 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) if (offers != NULL)
{ {
ByteArrayOutputStream rawOutput; ByteArrayOutputStream rawOutput;
@ -1057,7 +1057,7 @@ void ServerPlayer::broadcastCarriedItem()
void ServerPlayer::doCloseContainer() void ServerPlayer::doCloseContainer()
{ {
containerMenu->removed( dynamic_pointer_cast<Player>( shared_from_this() ) ); containerMenu->removed( std::dynamic_pointer_cast<Player>( shared_from_this() ) );
containerMenu = inventoryMenu; containerMenu = inventoryMenu;
} }
@ -1368,7 +1368,7 @@ void ServerPlayer::restoreFrom(std::shared_ptr<Player> oldPlayer, bool restoreAl
lastSentExp = -1; lastSentExp = -1;
lastSentHealth = -1; lastSentHealth = -1;
lastSentFood = -1; lastSentFood = -1;
entitiesToRemove = dynamic_pointer_cast<ServerPlayer>(oldPlayer)->entitiesToRemove; entitiesToRemove = std::dynamic_pointer_cast<ServerPlayer>(oldPlayer)->entitiesToRemove;
} }
void ServerPlayer::onEffectAdded(MobEffectInstance *effect) void ServerPlayer::onEffectAdded(MobEffectInstance *effect)
@ -1430,7 +1430,7 @@ void ServerPlayer::sendMessage(const std::wstring& message, ChatPacket::EChatPac
bool ServerPlayer::hasPermission(EGameCommand command) 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 // 4J - Don't use

2
Minecraft.Client/Player/ServerPlayerGameMode.cpp
View file

@ -247,7 +247,7 @@ bool ServerPlayerGameMode::destroyBlock(int x, int y, int z)
if( isCreative() ) if( isCreative() )
{ {
clientToUpdateRenderer = true; 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 // Establish whether we are sharing this chunk between client & server
MultiPlayerLevel *clientLevel = Minecraft::GetInstance()->getLevel(level->dimension->id); MultiPlayerLevel *clientLevel = Minecraft::GetInstance()->getLevel(level->dimension->id);

88
Minecraft.Client/Player/TrackedEntity.cpp
View file

@ -70,7 +70,7 @@ void TrackedEntity::tick(EntityTracker *tracker, std::vector<std::shared_ptr<Pla
// Moving forward special case for item frames // Moving forward special case for item frames
if (e->GetType()== eTYPE_ITEM_FRAME && tickCount % 10 == 0) 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(); std::shared_ptr<ItemInstance> item = frame->getItem();
if (item != NULL && item->getItem()->id == Item::map_Id && !e->removed) 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); std::shared_ptr<MapItemSavedData> data = Item::map->getSavedData(item, e->level);
for (AUTO_VAR(it,players->begin() ); it != players->end(); ++it) 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); data->tickCarriedBy(player, item);
if (!player->removed && player->connection && player->connection->countDelayedPackets() <= 5) 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; 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); // 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; dontSend = true;
// #ifdef _DEBUG // #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) // if(emp!=NULL)
// { // {
// app.DebugPrintf("Not sending this SetEntityMotionPacket to player - it's already been sent to a player on their console\n"); // 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; std::vector< std::shared_ptr<ServerPlayer> > sentTo;
broadcast(packet); 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) if (sp != NULL && sp->connection)
{ {
sp->connection->send(packet); sp->connection->send(packet);
@ -480,7 +480,7 @@ void TrackedEntity::updatePlayer(EntityTracker *tracker, std::shared_ptr<ServerP
yap = e->yd; yap = e->yd;
zap = e->zd; 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) if (plr != NULL)
{ {
app.DebugPrintf( "TrackedEntity:: Player '%ls' is now visible to player '%ls', %s.\n", 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 // 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))); 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()) 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)) ) ); 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(); std::vector<MobEffectInstance *> *activeEffects = mob->getActiveEffects();
for(AUTO_VAR(it, activeEffects->begin()); it != activeEffects->end(); ++it) 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++) 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 // 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); 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()) switch(e->GetType())
@ -590,7 +590,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break; break;
case eTYPE_SERVERPLAYER: 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 xuid = INVALID_XUID;
PlayerUID OnlineXuid = INVALID_XUID; PlayerUID OnlineXuid = INVALID_XUID;
if( player != NULL ) if( player != NULL )
@ -599,12 +599,12 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
OnlineXuid = player->getOnlineXuid(); 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. // 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; break;
case eTYPE_MINECART: 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::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::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) ); 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: case eTYPE_ENDERDRAGON:
{ {
yHeadRotp = Mth::floor(e->getYHeadRot() * 256 / 360); 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; break;
case eTYPE_FISHINGHOOK: 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) ); return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FISH_HOOK, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
} }
break; break;
case eTYPE_ARROW: 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) ); return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ARROW, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
} }
break; break;
@ -640,7 +640,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break; break;
case eTYPE_THROWNPOTION: 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; break;
case eTYPE_THROWNEXPBOTTLE: case eTYPE_THROWNEXPBOTTLE:
@ -660,7 +660,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break; break;
case eTYPE_SMALL_FIREBALL: 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; std::shared_ptr<AddEntityPacket> aep = nullptr;
if (fb->owner != NULL) if (fb->owner != NULL)
{ {
@ -678,7 +678,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break; break;
case eTYPE_DRAGON_FIREBALL: 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; std::shared_ptr<AddEntityPacket> aep = nullptr;
if (fb->owner != NULL) if (fb->owner != NULL)
{ {
@ -696,7 +696,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break; break;
case eTYPE_FIREBALL: 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; std::shared_ptr<AddEntityPacket> aep = nullptr;
if (fb->owner != NULL) if (fb->owner != NULL)
{ {
@ -729,18 +729,18 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break; break;
case eTYPE_FALLINGTILE: 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) ); return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING, ft->tile | (ft->data << 16), yRotp, xRotp, xp, yp, zp) );
} }
break; break;
case eTYPE_PAINTING: 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; break;
case eTYPE_ITEM_FRAME: 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; int ix= (int)frame->xTile;
@ -758,7 +758,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break; break;
case eTYPE_EXPERIENCEORB: 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; break;
default: default:
@ -768,7 +768,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
/* /*
if (e->GetType() == eTYPE_ITEMENTITY) 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) ); std::shared_ptr<AddItemEntityPacket> packet = std::shared_ptr<AddItemEntityPacket>( new AddItemEntityPacket(itemEntity, xp, yp, zp) );
itemEntity->x = packet->x / 32.0; itemEntity->x = packet->x / 32.0;
itemEntity->y = packet->y / 32.0; itemEntity->y = packet->y / 32.0;
@ -778,7 +778,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
if (e->GetType() == eTYPE_SERVERPLAYER ) 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 xuid = INVALID_XUID;
XUID OnlineXuid = INVALID_XUID; XUID OnlineXuid = INVALID_XUID;
if( player != NULL ) if( player != NULL )
@ -786,11 +786,11 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
xuid = player->getXuid(); xuid = player->getXuid();
OnlineXuid = player->getOnlineXuid(); 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) 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::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::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) ); 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) ); 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) 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) 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) ); 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) 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) ); 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) if (e->GetType() == eTYPE_SNOWBALL)
@ -823,7 +823,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
} }
if (e->GetType() == eTYPE_THROWNPOTION) 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) if (e->GetType() == eTYPE_THROWNEXPBOTTLE)
{ {
@ -839,7 +839,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
} }
if (e->GetType() == eTYPE_SMALL_FIREBALL) 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; std::shared_ptr<AddEntityPacket> aep = NULL;
if (fb->owner != NULL) if (fb->owner != NULL)
{ {
@ -856,7 +856,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
} }
if (e->GetType() == eTYPE_FIREBALL) 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; std::shared_ptr<AddEntityPacket> aep = NULL;
if (fb->owner != NULL) if (fb->owner != NULL)
{ {
@ -885,18 +885,18 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
} }
if (e->GetType() == eTYPE_FALLINGTILE) 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::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::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 (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) 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) 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; int ix= (int)frame->xTile;
@ -913,7 +913,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
} }
if (e->GetType() == eTYPE_EXPERIENCEORB) 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); assert(false);
*/ */

2
Minecraft.Client/Rendering/EntityRenderers/ArrowRenderer.cpp
View file

@ -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 - // 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 // 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" bindTexture(TN_ITEM_ARROWS); // 4J - was L"/item/arrows.png"
glPushMatrix(); glPushMatrix();

2
Minecraft.Client/Rendering/EntityRenderers/BlazeRenderer.cpp
View file

@ -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 - // 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 // 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(); int modelVersion = ((BlazeModel *) model)->modelVersion();
if (modelVersion != this->modelVersion) if (modelVersion != this->modelVersion)

2
Minecraft.Client/Rendering/EntityRenderers/BoatRenderer.cpp
View file

@ -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 - // 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 // 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(); glPushMatrix();

2
Minecraft.Client/Rendering/EntityRenderers/ChestRenderer.cpp
View file

@ -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) 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 // 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; int data;

2
Minecraft.Client/Rendering/EntityRenderers/ChickenRenderer.cpp
View file

@ -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) float ChickenRenderer::getBob(std::shared_ptr<Mob> _mob, float a)
{ {
// 4J - dynamic cast required because we aren't using templates/generics in our version // 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 flap = mob->oFlap+(mob->flap-mob->oFlap)*a;
float flapSpeed = mob->oFlapSpeed+(mob->flapSpeed-mob->oFlapSpeed)*a; float flapSpeed = mob->oFlapSpeed+(mob->flapSpeed-mob->oFlapSpeed)*a;

6
Minecraft.Client/Rendering/EntityRenderers/CreeperRenderer.cpp
View file

@ -11,7 +11,7 @@ CreeperRenderer::CreeperRenderer() : MobRenderer( new CreeperModel(), 0.5f )
void CreeperRenderer::scale(std::shared_ptr<Mob> mob, float a) 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); 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) 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); 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) 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 // 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->isPowered())
{ {
if (mob->isInvisible()) glDepthMask(false); if (mob->isInvisible()) glDepthMask(false);

2
Minecraft.Client/Rendering/EntityRenderers/EnchantTableRenderer.cpp
View file

@ -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) 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 // 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__ #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 // 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

2
Minecraft.Client/Rendering/EntityRenderers/EnderChestRenderer.cpp
View file

@ -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) 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 // 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; int data = 0;

2
Minecraft.Client/Rendering/EntityRenderers/EnderCrystalRenderer.cpp
View file

@ -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 - // 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 // 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) if (currentModel != EnderCrystalModel::MODEL_ID)
{ {
model = new EnderCrystalModel(0); model = new EnderCrystalModel(0);

10
Minecraft.Client/Rendering/EntityRenderers/EnderDragonRenderer.cpp
View file

@ -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) 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 // 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 // 4J - reorganised a bit so we can free allocations
double lpComponents[3]; 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) 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 // 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) 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) 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 // 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; EnderDragonRenderer::bossInstance = mob;
if (currentModel != DragonModel::MODEL_ID) 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) void EnderDragonRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
{ {
// 4J - dynamic cast required because we aren't using templates/generics in our version // 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); MobRenderer::additionalRendering(mob, a);
Tesselator *t = Tesselator::getInstance(); 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) 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 // 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) if (layer == 1)
{ {

6
Minecraft.Client/Rendering/EntityRenderers/EnderManRenderer.cpp
View file

@ -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 - // 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 // 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->carrying = mob->getCarryingTile() > 0;
model->creepy = mob->isCreepy(); 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 - // 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 // 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); 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 - // 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 // 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; if (layer != 0) return -1;

2
Minecraft.Client/Rendering/EntityRenderers/EntityRenderDispatcher.cpp
View file

@ -197,7 +197,7 @@ void EntityRenderDispatcher::prepare(Level *level, Textures *textures, Font *fon
playerRotX = player->xRotO + (player->xRot - player->xRotO) * a; 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) if (pl->ThirdPersonView() == 2)
{ {
playerRotY += 180; playerRotY += 180;

10
Minecraft.Client/Rendering/EntityRenderers/EntityRenderer.cpp
View file

@ -160,17 +160,17 @@ void EntityRenderer::renderShadow(std::shared_ptr<Entity> e, double x, double y,
glDepthMask(false); glDepthMask(false);
float r = shadowRadius; 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; bool isLocalPlayer = false;
float fYLocalPlayerShadowOffset=0.0f; float fYLocalPlayerShadowOffset=0.0f;
//if (dynamic_pointer_cast<Mob>(e) != NULL) //if (std::dynamic_pointer_cast<Mob>(e) != NULL)
if (mob != 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(); 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 != NULL)
{ {
if (animal->isBaby()) 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; isLocalPlayer=true;
} }

2
Minecraft.Client/Rendering/EntityRenderers/ExperienceOrbRenderer.cpp
View file

@ -21,7 +21,7 @@ ExperienceOrbRenderer::ExperienceOrbRenderer()
void ExperienceOrbRenderer::render(std::shared_ptr<Entity> _orb, double x, double y, double z, float rot, float a) 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(); glPushMatrix();
glTranslatef((float) x, (float) y, (float) z); glTranslatef((float) x, (float) y, (float) z);

2
Minecraft.Client/Rendering/EntityRenderers/FallingTileRenderer.cpp
View file

@ -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) 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 // 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(); glPushMatrix();
glTranslatef((float) x, (float) y, (float) z); glTranslatef((float) x, (float) y, (float) z);

2
Minecraft.Client/Rendering/EntityRenderers/FireballRenderer.cpp
View file

@ -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) 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 // 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(); glPushMatrix();

4
Minecraft.Client/Rendering/EntityRenderers/FishingHookRenderer.cpp
View file

@ -11,7 +11,7 @@
void FishingHookRenderer::render(std::shared_ptr<Entity> _hook, double x, double y, double z, float rot, float a) 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 // 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(); 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 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 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 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 // 4J-PB - changing this to be per player
//if (this->entityRenderDispatcher->options->thirdPersonView) //if (this->entityRenderDispatcher->options->thirdPersonView)

2
Minecraft.Client/Rendering/EntityRenderers/GhastRenderer.cpp
View file

@ -9,7 +9,7 @@ GhastRenderer::GhastRenderer() : MobRenderer(new GhastModel(), 0.5f)
void GhastRenderer::scale(std::shared_ptr<Mob> mob, float a) 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; float ss = (ghast->oCharge+(ghast->charge-ghast->oCharge)*a)/20.0f;
if (ss<0) ss = 0; if (ss<0) ss = 0;

2
Minecraft.Client/Rendering/EntityRenderers/ItemFrameRenderer.cpp
View file

@ -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 - // 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 // 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(); glPushMatrix();
float xOffs = (float) (itemFrame->x - x) - 0.5f; float xOffs = (float) (itemFrame->x - x) - 0.5f;

2
Minecraft.Client/Rendering/EntityRenderers/ItemInHandRenderer.cpp
View file

@ -319,7 +319,7 @@ void ItemInHandRenderer::render(float a)
float fudgeY = 0.0f; float fudgeY = 0.0f;
float fudgeZ = 0.0f; float fudgeZ = 0.0f;
bool splitHoriz = false; 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 )
{ {
if( localPlayer->m_iScreenSection == C4JRender::VIEWPORT_TYPE_SPLIT_BOTTOM || if( localPlayer->m_iScreenSection == C4JRender::VIEWPORT_TYPE_SPLIT_BOTTOM ||

2
Minecraft.Client/Rendering/EntityRenderers/ItemRenderer.cpp
View file

@ -32,7 +32,7 @@ ItemRenderer::~ItemRenderer()
void ItemRenderer::render(std::shared_ptr<Entity> _itemEntity, double x, double y, double z, float rot, float a) 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 // 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); random->setSeed(187);
std::shared_ptr<ItemInstance> item = itemEntity->getItem(); std::shared_ptr<ItemInstance> item = itemEntity->getItem();

2
Minecraft.Client/Rendering/EntityRenderers/ItemSpriteRenderer.cpp
View file

@ -37,7 +37,7 @@ void ItemSpriteRenderer::render(std::shared_ptr<Entity> e, double x, double y, d
if (icon == PotionItem::getTexture(PotionItem::THROWABLE_ICON) ) 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 red = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f; float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f; float b = ((col) & 0xff) / 255.0f;

4
Minecraft.Client/Rendering/EntityRenderers/LavaSlimeRenderer.cpp
View file

@ -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 - // 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 // 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(); int modelVersion = ((LavaSlimeModel *) model)->getModelVersion();
if (modelVersion != this->modelVersion) 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 - // 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 // 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(); int size = slime->getSize();
float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1); float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1);
float w = 1 / (ss + 1); float w = 1 / (ss + 1);

2
Minecraft.Client/Rendering/EntityRenderers/LightningBoltRenderer.cpp
View file

@ -6,7 +6,7 @@
void LightningBoltRenderer::render(std::shared_ptr<Entity> _bolt, double x, double y, double z, float rot, float a) 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 // 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(); Tesselator *t = Tesselator::getInstance();

2
Minecraft.Client/Rendering/EntityRenderers/MinecartRenderer.cpp
View file

@ -13,7 +13,7 @@ MinecartRenderer::MinecartRenderer()
void MinecartRenderer::render(std::shared_ptr<Entity> _cart, double x, double y, double z, float rot, float a) 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 // 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(); glPushMatrix();

10
Minecraft.Client/Rendering/EntityRenderers/MobRenderer.cpp
View file

@ -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 // 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. // 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(); glPushMatrix();
glDisable(GL_CULL_FACE); 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 bodyRot = rotlerp(mob->yBodyRotO, mob->yBodyRot, a);
float headRot = rotlerp(mob->yHeadRotO, mob->yHeadRot, 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); bodyRot = rotlerp(riding->yBodyRotO, riding->yBodyRot, a);
float headDiff = Mth::wrapDegrees(headRot - bodyRot); 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) 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()); bindTexture(mob->customTextureUrl, mob->getTexture());
if (!mob->isInvisible()) if (!mob->isInvisible())
@ -396,7 +396,7 @@ void MobRenderer::renderNameTag(std::shared_ptr<Mob> mob, const std::wstring& Or
Tesselator *t = Tesselator::getInstance(); Tesselator *t = Tesselator::getInstance();
int offs = 0; 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; if (player != NULL && app.isXuidDeadmau5( player->getXuid() ) ) offs = -10;
std::wstring playerName; std::wstring playerName;

2
Minecraft.Client/Rendering/EntityRenderers/MobSpawnerRenderer.cpp
View file

@ -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) 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 // 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(); glPushMatrix();
glTranslatef((float) x + 0.5f, (float) y, (float) z + 0.5f); glTranslatef((float) x + 0.5f, (float) y, (float) z + 0.5f);

4
Minecraft.Client/Rendering/EntityRenderers/MushroomCowRenderer.cpp
View file

@ -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 - // 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 // 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 // 4J Stu - No need to do the cast, just pass through as-is
MobRenderer::render(_mob, x, y, z, rot, a); 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 - // 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 // 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); MobRenderer::additionalRendering(mob, a);
if (mob->isBaby()) return; if (mob->isBaby()) return;
bindTexture(TN_TERRAIN); // 4J was "/terrain.png" bindTexture(TN_TERRAIN); // 4J was "/terrain.png"

2
Minecraft.Client/Rendering/EntityRenderers/OcelotRenderer.cpp
View file

@ -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 - // 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 // 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); MobRenderer::scale(mob, a);
if (mob->isTame()) if (mob->isTame())
{ {

2
Minecraft.Client/Rendering/EntityRenderers/PaintingRenderer.cpp
View file

@ -14,7 +14,7 @@ PaintingRenderer::PaintingRenderer()
void PaintingRenderer::render(std::shared_ptr<Entity> _painting, double x, double y, double z, float rot, float a) 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 // 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); random->setSeed(187);

2
Minecraft.Client/Rendering/EntityRenderers/PigRenderer.cpp
View file

@ -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) 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 // 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); MemSect(31);
bindTexture(TN_MOB_SADDLE); // 4J was L"/mob/saddle.png" bindTexture(TN_MOB_SADDLE); // 4J was L"/mob/saddle.png"

2
Minecraft.Client/Rendering/EntityRenderers/PistonPieceRenderer.cpp
View file

@ -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) 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 // 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()]; 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 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

18
Minecraft.Client/Rendering/EntityRenderers/PlayerRenderer.cpp
View file

@ -49,7 +49,7 @@ unsigned int PlayerRenderer::getNametagColour(int index)
int PlayerRenderer::prepareArmor(std::shared_ptr<Mob> _player, int layer, float a) 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 // 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) // 4J-PB - need to disable rendering armour for some special skins (Daleks)
unsigned int uiAnimOverrideBitmask=player->getAnimOverrideBitmask(); 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) 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 // 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); std::shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
if (itemInstance != NULL) 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) 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 // 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; 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(); armorParts1->sneaking = armorParts2->sneaking = humanoidModel->sneaking = mob->isSneaking();
double yp = y - mob->heightOffset; 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; 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) 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 // 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 if (Minecraft::renderNames() && mob != entityRenderDispatcher->cameraEntity
&& !mob->isInvisibleTo(Minecraft::GetInstance()->player) ) // 4J-JEV: Todo, move to LivingEntityRenderer. && !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); MobRenderer::additionalRendering(_mob,a);
// 4J - dynamic cast required because we aren't using templates/generics in our version // 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); std::shared_ptr<ItemInstance> headGear = mob->inventory->getArmor(3);
if (headGear != NULL) if (headGear != NULL)
@ -543,7 +543,7 @@ void PlayerRenderer::renderHand()
void PlayerRenderer::setupPosition(std::shared_ptr<Mob> _mob, double x, double y, double z) 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 // 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()) 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) 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 // 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()) 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) 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; if(player != NULL && player->hasInvisiblePrivilege()) return;
} }
EntityRenderer::renderShadow(e,x,y,z,pow,a); EntityRenderer::renderShadow(e,x,y,z,pow,a);

2
Minecraft.Client/Rendering/EntityRenderers/SheepRenderer.cpp
View file

@ -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) 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 // 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() && 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'. !sheep->isInvisibleTo(Minecraft::GetInstance()->player)) // 4J-JEV: Todo, merge with java fix (for invisible sheep armour) in '1.7.5'.

2
Minecraft.Client/Rendering/EntityRenderers/SignRenderer.cpp
View file

@ -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) 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 // 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(); Tile *tile = sign->getTile();

2
Minecraft.Client/Rendering/EntityRenderers/SkullTileRenderer.cpp
View file

@ -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) 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()); renderSkull((float) x, (float) y, (float) z, skull->getData() & SkullTile::PLACEMENT_MASK, skull->getRotation() * 360 / 16.0f, skull->getSkullType(), skull->getExtraType());
} }

4
Minecraft.Client/Rendering/EntityRenderers/SlimeRenderer.cpp
View file

@ -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) 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 // 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; 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) void SlimeRenderer::scale(std::shared_ptr<Mob> _slime, float a)
{ {
// 4J - dynamic cast required because we aren't using templates/generics in our version // 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 size = (float) slime->getSize();
float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1); float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1);

2
Minecraft.Client/Rendering/EntityRenderers/SnowManRenderer.cpp
View file

@ -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 - // 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 // 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); MobRenderer::additionalRendering(mob, a);
std::shared_ptr<ItemInstance> headGear = std::shared_ptr<ItemInstance>( new ItemInstance(Tile::pumpkin, 1) ); std::shared_ptr<ItemInstance> headGear = std::shared_ptr<ItemInstance>( new ItemInstance(Tile::pumpkin, 1) );

4
Minecraft.Client/Rendering/EntityRenderers/SpiderRenderer.cpp
View file

@ -16,7 +16,7 @@ float SpiderRenderer::getFlipDegrees(std::shared_ptr<Mob> spider)
int SpiderRenderer::prepareArmor(std::shared_ptr<Mob> _spider, int layer, float a) 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 // 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; if (layer!=0) return -1;
MemSect(31); 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) void SpiderRenderer::scale(std::shared_ptr<Mob> _mob, float a)
{ {
// 4J - dynamic cast required because we aren't using templates/generics in our version // 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(); float scale = mob->getModelScale();
glScalef(scale, scale, scale); glScalef(scale, scale, scale);
} }

4
Minecraft.Client/Rendering/EntityRenderers/SquidRenderer.cpp
View file

@ -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) 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 // 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 bodyXRot = (mob->xBodyRotO + (mob->xBodyRot - mob->xBodyRotO) * a);
float bodyZRot = (mob->zBodyRotO + (mob->zBodyRot - mob->zBodyRotO) * 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) float SquidRenderer::getBob(std::shared_ptr<Mob> _mob, float a)
{ {
// 4J - dynamic cast required because we aren't using templates/generics in our version // 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; return mob->oldTentacleAngle + (mob->tentacleAngle - mob->oldTentacleAngle) * a;
} }

2
Minecraft.Client/Rendering/EntityRenderers/TheEndPortalRenderer.cpp
View file

@ -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) 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 // 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 xx = (float) (tileEntityRenderDispatcher->xPlayer);
float yy = (float) (tileEntityRenderDispatcher->yPlayer); float yy = (float) (tileEntityRenderDispatcher->yPlayer);
float zz = (float) (tileEntityRenderDispatcher->zPlayer); float zz = (float) (tileEntityRenderDispatcher->zPlayer);

2
Minecraft.Client/Rendering/EntityRenderers/TntRenderer.cpp
View file

@ -13,7 +13,7 @@ TntRenderer::TntRenderer()
void TntRenderer::render(std::shared_ptr<Entity> _tnt, double x, double y, double z, float rot, float a) 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 // 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(); glPushMatrix();
glTranslatef((float) x, (float) y, (float) z); glTranslatef((float) x, (float) y, (float) z);

4
Minecraft.Client/Rendering/EntityRenderers/VillagerGolemRenderer.cpp
View file

@ -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 - // 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 // 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); MobRenderer::setupRotations(mob, bob, bodyRot, a);
if (mob->walkAnimSpeed < 0.01) return; 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 - // 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 // 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); MobRenderer::additionalRendering(mob, a);
if (mob->getOfferFlowerTick() == 0) return; if (mob->getOfferFlowerTick() == 0) return;

2
Minecraft.Client/Rendering/EntityRenderers/VillagerRenderer.cpp
View file

@ -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 - // 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 // 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; float s = 15 / 16.0f;
if (mob->getAge() < 0) if (mob->getAge() < 0)
{ {

4
Minecraft.Client/Rendering/EntityRenderers/WolfRenderer.cpp
View file

@ -11,7 +11,7 @@ WolfRenderer::WolfRenderer(Model *model, Model *armor, float shadow) : MobRender
float WolfRenderer::getBob(std::shared_ptr<Mob> _mob, float a) float WolfRenderer::getBob(std::shared_ptr<Mob> _mob, float a)
{ {
// 4J - dynamic cast required because we aren't using templates/generics in our version // 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(); 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'. 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()) if (layer == 0 && wolf->isWet())
{ {
float brightness = wolf->getBrightness(a) * wolf->getWetShade(a); float brightness = wolf->getBrightness(a) * wolf->getWetShade(a);

8
Minecraft.Client/Rendering/EntityRenderers/ZombieRenderer.cpp
View file

@ -36,21 +36,21 @@ void ZombieRenderer::createArmorParts()
int ZombieRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a) 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); swapArmor(mob);
return HumanoidMobRenderer::prepareArmor(_mob, layer, a); return HumanoidMobRenderer::prepareArmor(_mob, layer, a);
} }
void ZombieRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float 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); swapArmor(mob);
HumanoidMobRenderer::render(_mob, x, y, z, rot, a); HumanoidMobRenderer::render(_mob, x, y, z, rot, a);
} }
void ZombieRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float 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); swapArmor(mob);
HumanoidMobRenderer::additionalRendering(_mob, a); 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) 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()) if (mob->isConverting())
{ {
bodyRot += (float) (cos(mob->tickCount * 3.25) * PI * .25f); bodyRot += (float) (cos(mob->tickCount * 3.25) * PI * .25f);

28
Minecraft.Client/Rendering/GameRenderer.cpp
View file

@ -276,7 +276,7 @@ void GameRenderer::tick(bool first) // 4J - add bFirst
if (mc->cameraTargetPlayer == NULL) 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)); 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() 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; int playerIdx = player ? player->GetXboxPad() : 0;
tFov[playerIdx] = player->getFieldOfViewModifier(); tFov[playerIdx] = player->getFieldOfViewModifier();
@ -420,7 +420,7 @@ float GameRenderer::getFov(float a, bool applyEffects)
{ {
if (cameraFlip > 0 ) return 90; 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; int playerIdx = player ? player->GetXboxPad() : 0;
float fov = m_fov;//70; float fov = m_fov;//70;
if (applyEffects) if (applyEffects)
@ -470,12 +470,12 @@ void GameRenderer::bobHurt(float a)
void GameRenderer::bobView(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) if(player==NULL)
{ {
return; 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 wda = player->walkDist - player->walkDistO;
float b = -(player->walkDist + wda * a); float b = -(player->walkDist + wda * a);
@ -490,7 +490,7 @@ void GameRenderer::bobView(float a)
void GameRenderer::moveCameraToPlayer(float a) void GameRenderer::moveCameraToPlayer(float a)
{ {
std::shared_ptr<Mob> player = mc->cameraTargetPlayer; 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; float heightOffset = player->heightOffset - 1.62f;
double x = player->xo + (player->x - player->xo) * a; double x = player->xo + (player->x - player->xo) * a;
@ -724,7 +724,7 @@ void GameRenderer::renderItemInHand(float a, int eye)
{ {
if (cameraFlip > 0) return; 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 // 4J-PB - to turn off the hand for screenshots, but not when the item held is a map
if ( localplayer!=NULL) if ( localplayer!=NULL)
@ -1405,10 +1405,10 @@ void GameRenderer::renderLevel(float a, __int64 until)
PIXEndNamedEvent(); PIXEndNamedEvent();
turnOffLightLayer(a); // 4J - brought forward from 1.8.2 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) 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); glDisable(GL_ALPHA_TEST);
levelRenderer->renderHit(player, mc->hitResult, 0, player->inventory->getSelected(), a); levelRenderer->renderHit(player, mc->hitResult, 0, player->inventory->getSelected(), a);
levelRenderer->renderHitOutline(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); glEnable(GL_CULL_FACE);
glDisable(GL_BLEND); 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)) 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); glDisable(GL_ALPHA_TEST);
levelRenderer->renderHit(player, mc->hitResult, 0, player->inventory->getSelected(), a); levelRenderer->renderHit(player, mc->hitResult, 0, player->inventory->getSelected(), a);
levelRenderer->renderHitOutline(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); glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE); 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); glDisable(GL_BLEND);
if (mc->options->isCloudsOn()) 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 // 4J - check for creative mode brought forward from 1.2.3
bool creative = false; 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) if (i == 999)

6
Minecraft.Client/Rendering/LevelRenderer.cpp
View file

@ -540,7 +540,7 @@ void LevelRenderer::renderEntities(Vec3 *cam, Culler *culler, float a)
{ {
// 4J-PB - changing this to be per player // 4J-PB - changing this to be per player
//if (entity == mc->cameraTargetPlayer && !mc->options->thirdPersonView && !mc->cameraTargetPlayer->isSleeping()) continue; //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; 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; break;
case eParticleType_instantSpell: case eParticleType_instantSpell:
particle = std::shared_ptr<Particle>(new SpellParticle(lev, x, y, z, xa, ya, za)); 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; break;
case eParticleType_note: case eParticleType_note:
particle = std::shared_ptr<Particle>( new NoteParticle(lev, x, y, z, xa, ya, za) ); 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 ) ) else if( ( eParticleType >= eParticleType_tilecrack_base ) && ( eParticleType <= eParticleType_tilecrack_last ) )
{ {
int id = PARTICLE_CRACK_ID(eParticleType), data = PARTICLE_CRACK_DATA(eParticleType); 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) );
} }
} }

2
Minecraft.Client/Rendering/Models/DragonModel.cpp
View file

@ -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) void DragonModel::render(std::shared_ptr<Entity> entity, float time, float r, float bob, float yRot, float xRot, float scale, bool usecompiled)
{ {
glPushMatrix(); 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; float ttt = dragon->oFlapTime + (dragon->flapTime - dragon->oFlapTime) * a;
jaw->xRot = (float) (Mth::sin(ttt * PI * 2) + 1) * 0.2f; jaw->xRot = (float) (Mth::sin(ttt * PI * 2) + 1) * 0.2f;

2
Minecraft.Client/Rendering/Models/LavaSlimeModel.cpp
View file

@ -43,7 +43,7 @@ int LavaSlimeModel::getModelVersion()
void LavaSlimeModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r, float a) 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); float slimeSquish = (lavaSlime->oSquish + (lavaSlime->squish - lavaSlime->oSquish) * a);
if (slimeSquish < 0) if (slimeSquish < 0)

2
Minecraft.Client/Rendering/Models/OcelotModel.cpp
View file

@ -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) 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->y = bodyWalkY;
body->z = bodyWalkZ; body->z = bodyWalkZ;

2
Minecraft.Client/Rendering/Models/SheepFurModel.cpp
View file

@ -45,7 +45,7 @@ void SheepFurModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float
{ {
QuadrupedModel::prepareMobModel(mob, time, r, a); 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; head->y = 6 + sheep->getHeadEatPositionScale(a) * 9.0f;
headXRot = sheep->getHeadEatAngleScale(a); headXRot = sheep->getHeadEatAngleScale(a);
} }

2
Minecraft.Client/Rendering/Models/SheepModel.cpp
View file

@ -24,7 +24,7 @@ void SheepModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r,
{ {
QuadrupedModel::prepareMobModel(mob, time, r, a); 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; head->y = 6 + sheep->getHeadEatPositionScale(a) * 9.0f;
headXRot = sheep->getHeadEatAngleScale(a); headXRot = sheep->getHeadEatAngleScale(a);
} }

2
Minecraft.Client/Rendering/Models/VillagerGolemModel.cpp
View file

@ -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) 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(); int attackTick = vg->getAttackAnimationTick();
if (attackTick > 0) if (attackTick > 0)
{ {

2
Minecraft.Client/Rendering/Models/WolfModel.cpp
View file

@ -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) 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()) if (wolf->isAngry())
{ {

4
Minecraft.Client/Rendering/Particles/Particle.cpp
View file

@ -66,14 +66,14 @@ std::shared_ptr<Particle> Particle::setPower(float power)
xd *= power; xd *= power;
yd = (yd - 0.1f) * power + 0.1f; yd = (yd - 0.1f) * power + 0.1f;
zd *= power; 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) std::shared_ptr<Particle> Particle::scale(float scale)
{ {
setSize(0.2f * scale, 0.2f * scale); setSize(0.2f * scale, 0.2f * scale);
size *= 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) void Particle::setColor(float r, float g, float b)

8
Minecraft.Client/Rendering/Particles/TerrainParticle.cpp
View file

@ -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 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 int col = tile->getColor(level, x, y, z, data); // 4J - added data parameter
rCol *= ((col >> 16) & 0xff) / 255.0f; rCol *= ((col >> 16) & 0xff) / 255.0f;
gCol *= ((col >> 8) & 0xff) / 255.0f; gCol *= ((col >> 8) & 0xff) / 255.0f;
bCol *= ((col) & 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) 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); int col = tile->getColor(data);
rCol *= ((col >> 16) & 0xff) / 255.0f; rCol *= ((col >> 16) & 0xff) / 255.0f;
gCol *= ((col >> 8) & 0xff) / 255.0f; gCol *= ((col >> 8) & 0xff) / 255.0f;
bCol *= ((col) & 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() int TerrainParticle::getParticleTexture()

2
Minecraft.Client/UI/Screens/CraftingScreen.cpp
View file

@ -11,7 +11,7 @@ CraftingScreen::CraftingScreen(std::shared_ptr<Inventory> inventory, Level *leve
void CraftingScreen::removed() void CraftingScreen::removed()
{ {
AbstractContainerScreen::removed(); AbstractContainerScreen::removed();
menu->removed(dynamic_pointer_cast<Player>(minecraft->player)); menu->removed(std::dynamic_pointer_cast<Player>(minecraft->player));
} }
void CraftingScreen::renderLabels() void CraftingScreen::renderLabels()

2
Minecraft.World/AI/Control/LookControl.cpp
View file

@ -16,7 +16,7 @@ LookControl::LookControl(Mob *mob)
void LookControl::setLookAt(std::shared_ptr<Entity> target, float yMax, float xMax) void LookControl::setLookAt(std::shared_ptr<Entity> target, float yMax, float xMax)
{ {
this->wantedX = target->x; 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(); if (targetMob != NULL) this->wantedY = target->y + targetMob->getHeadHeight();
else this->wantedY = (target->bb->y0 + target->bb->y1) / 2; else this->wantedY = (target->bb->y0 + target->bb->y1) / 2;
this->wantedZ = target->z; this->wantedZ = target->z;

4
Minecraft.World/AI/Goals/ArrowAttackGoal.cpp
View file

@ -72,13 +72,13 @@ void ArrowAttackGoal::fireAtTarget()
std::shared_ptr<Mob> tar = target.lock(); std::shared_ptr<Mob> tar = target.lock();
if (projectileType == ArrowType) 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->playSound(mob->shared_from_this(), eSoundType_RANDOM_BOW, 1.0f, 1 / (mob->getRandom()->nextFloat() * 0.4f + 0.8f));
level->addEntity(arrow); level->addEntity(arrow);
} }
else if (projectileType == SnowballType) 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 xd = tar->x - mob->x;
double yd = (tar->y + tar->getHeadHeight() - 1.1f) - snowball->y; double yd = (tar->y + tar->getHeadHeight() - 1.1f) - snowball->y;
double zd = tar->z - mob->z; double zd = tar->z - mob->z;

4
Minecraft.World/AI/Goals/AvoidPlayerGoal.cpp
View file

@ -33,7 +33,7 @@ bool AvoidPlayerGoal::canUse()
{ {
if (avoidType == typeid(Player)) 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; if (tamableAnimal != NULL && tamableAnimal->isTame()) return false;
toAvoid = std::weak_ptr<Entity>(mob->level->getNearestPlayer(mob->shared_from_this(), maxDist)); toAvoid = std::weak_ptr<Entity>(mob->level->getNearestPlayer(mob->shared_from_this(), maxDist));
if (toAvoid.lock() == NULL) return false; if (toAvoid.lock() == NULL) return false;
@ -52,7 +52,7 @@ bool AvoidPlayerGoal::canUse()
if (!mob->getSensing()->canSee(toAvoid.lock())) return false; 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 (pos == NULL) return false;
if (toAvoid.lock()->distanceToSqr(pos->x, pos->y, pos->z) < toAvoid.lock()->distanceToSqr(mob->shared_from_this())) return false; if (toAvoid.lock()->distanceToSqr(pos->x, pos->y, pos->z) < toAvoid.lock()->distanceToSqr(mob->shared_from_this())) return false;
delete path; delete path;

2
Minecraft.World/AI/Goals/BreedGoal.cpp
View file

@ -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)); 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) 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)) if (animal->canMate(p))
{ {
delete others; delete others;

4
Minecraft.World/AI/Goals/ControlledByPlayerGoal.cpp
View file

@ -36,13 +36,13 @@ void ControlledByPlayerGoal::stop()
bool ControlledByPlayerGoal::canUse() 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()); return mob->isAlive() && player && (boosting || mob->canBeControlledByRider());
} }
void ControlledByPlayerGoal::tick() 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; PathfinderMob *pig = (PathfinderMob *)mob;
float yrd = Mth::wrapDegrees(player->yRot - mob->yRot) * 0.5f; float yrd = Mth::wrapDegrees(player->yRot - mob->yRot) * 0.5f;

2
Minecraft.World/AI/Goals/DefendVillageTargetGoal.cpp
View file

@ -13,7 +13,7 @@ bool DefendVillageTargetGoal::canUse()
{ {
std::shared_ptr<Village> village = golem->getVillage(); std::shared_ptr<Village> village = golem->getVillage();
if (village == NULL) return false; 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); return canAttack(potentialTarget.lock(), false);
} }

2
Minecraft.World/AI/Goals/FollowParentGoal.cpp
View file

@ -24,7 +24,7 @@ bool FollowParentGoal::canUse()
double closestDistSqr = Double::MAX_VALUE; double closestDistSqr = Double::MAX_VALUE;
for(AUTO_VAR(it, parents->begin()); it != parents->end(); ++it) 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; if (parent->getAge() < 0) continue;
double distSqr = animal->distanceToSqr(parent); double distSqr = animal->distanceToSqr(parent);
if (distSqr > closestDistSqr) continue; if (distSqr > closestDistSqr) continue;

2
Minecraft.World/AI/Goals/HurtByTargetGoal.cpp
View file

@ -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)); 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) 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 (this->mob->shared_from_this() == other) continue;
if (other->getTarget() != NULL) continue; if (other->getTarget() != NULL) continue;
other->setTarget(mob->getLastHurtByMob()); other->setTarget(mob->getLastHurtByMob());

2
Minecraft.World/AI/Goals/LookAtTradingPlayerGoal.cpp
View file

@ -12,7 +12,7 @@ bool LookAtTradingPlayerGoal::canUse()
{ {
if (villager->isTrading()) 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 true;
} }
return false; return false;

2
Minecraft.World/AI/Goals/MakeLoveGoal.cpp
View file

@ -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()); std::shared_ptr<Entity> mate = level->getClosestEntityOfClass(typeid(Villager), villager->bb->grow(8, 3, 8), villager->shared_from_this());
if (mate == NULL) return false; 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; if (partner.lock()->getAge() != 0) return false;
return true; return true;

2
Minecraft.World/AI/Goals/MoveIndoorsGoal.cpp
View file

@ -44,7 +44,7 @@ void MoveIndoorsGoal::start()
} }
if (mob->distanceToSqr(_doorInfo->getIndoorX(), _doorInfo->y, _doorInfo->getIndoorZ()) > 16 * 16) 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); 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); else mob->getNavigation()->moveTo(_doorInfo->getIndoorX() + 0.5, _doorInfo->getIndoorY(), _doorInfo->getIndoorZ() + 0.5, 0.3f);

2
Minecraft.World/AI/Goals/MoveThroughVillageGoal.cpp
View file

@ -46,7 +46,7 @@ bool MoveThroughVillageGoal::canUse()
mob->getNavigation()->setCanOpenDoors(oldCanOpenDoors); mob->getNavigation()->setCanOpenDoors(oldCanOpenDoors);
if (path != NULL) return true; 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; if (pos == NULL) return false;
mob->getNavigation()->setCanOpenDoors(false); mob->getNavigation()->setCanOpenDoors(false);
delete path; delete path;

2
Minecraft.World/AI/Goals/MoveTowardsRestrictionGoal.cpp
View file

@ -19,7 +19,7 @@ bool MoveTowardsRestrictionGoal::canUse()
{ {
if (mob->isWithinRestriction()) return false; if (mob->isWithinRestriction()) return false;
Pos *towards = mob->getRestrictCenter(); 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; if (pos == NULL) return false;
wantedX = pos->x; wantedX = pos->x;
wantedY = pos->y; wantedY = pos->y;

2
Minecraft.World/AI/Goals/MoveTowardsTargetGoal.cpp
View file

@ -19,7 +19,7 @@ bool MoveTowardsTargetGoal::canUse()
target = std::weak_ptr<Mob>(mob->getTarget()); target = std::weak_ptr<Mob>(mob->getTarget());
if (target.lock() == NULL) return false; if (target.lock() == NULL) return false;
if (target.lock()->distanceToSqr(mob->shared_from_this()) > within * within) 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; if (pos == NULL) return false;
wantedX = pos->x; wantedX = pos->x;
wantedY = pos->y; wantedY = pos->y;

2
Minecraft.World/AI/Goals/NearestAttackableTargetGoal.cpp
View file

@ -52,7 +52,7 @@ bool NearestAttackableTargetGoal::canUse()
std::sort(entities->begin(), entities->end(), *distComp); std::sort(entities->begin(), entities->end(), *distComp);
for(AUTO_VAR(it, entities->begin()); it != entities->end(); ++it) 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)) if (canAttack(potTarget, false))
{ {
target = std::weak_ptr<Mob>(potTarget); target = std::weak_ptr<Mob>(potTarget);

2
Minecraft.World/AI/Goals/OcelotSitOnTileGoal.cpp
View file

@ -107,7 +107,7 @@ bool OcelotSitOnTileGoal::isValidTarget(Level *level, int x, int y, int z)
if (tile == Tile::chest_Id) 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) if (chest->openCount < 1)
{ {

2
Minecraft.World/AI/Goals/OfferFlowerGoal.cpp
View file

@ -16,7 +16,7 @@ bool OfferFlowerGoal::canUse()
{ {
if (!golem->level->isDay()) return false; if (!golem->level->isDay()) return false;
if (golem->getRandom()->nextInt(8000) != 0) 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; return villager.lock() != NULL;
} }

2
Minecraft.World/AI/Goals/PanicGoal.cpp
View file

@ -16,7 +16,7 @@ PanicGoal::PanicGoal(PathfinderMob *mob, float speed)
bool PanicGoal::canUse() bool PanicGoal::canUse()
{ {
if (mob->getLastHurtByMob() == NULL) return false; 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; if (pos == NULL) return false;
posX = pos->x; posX = pos->x;
posY = pos->y; posY = pos->y;

6
Minecraft.World/AI/Goals/PlayGoal.cpp
View file

@ -32,7 +32,7 @@ bool PlayGoal::canUse()
{ {
std::shared_ptr<Entity> c = *it; std::shared_ptr<Entity> c = *it;
if (c.get() == mob) continue; 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->isChasing()) continue;
if (friendV->getAge() >= 0) continue; if (friendV->getAge() >= 0) continue;
double distSqr = friendV->distanceToSqr(mob->shared_from_this()); double distSqr = friendV->distanceToSqr(mob->shared_from_this());
@ -44,7 +44,7 @@ bool PlayGoal::canUse()
if (followFriend.lock() == NULL) 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; if (pos == NULL) return false;
} }
return true; return true;
@ -78,7 +78,7 @@ void PlayGoal::tick()
{ {
if (mob->getNavigation()->isDone()) 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; if (pos == NULL) return;
mob->getNavigation()->moveTo(pos->x, pos->y, pos->z, speed); mob->getNavigation()->moveTo(pos->x, pos->y, pos->z, speed);
} }

Some files were not shown because too many files have changed in this diff Show more