backups/4jcraft
1
0
Fork 0
mirror of https://github.com/4jcraft/4jcraft.git synced 2026-05-01 08:03:38 +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();
}
if (!server->isNpcsEnabled() && (dynamic_pointer_cast<Npc>(e) != NULL))
if (!server->isNpcsEnabled() && (std::dynamic_pointer_cast<Npc>(e) != NULL))
{
e->remove();
}
if (e->rider.lock() == NULL || (dynamic_pointer_cast<Player>(e->rider.lock())==NULL) ) // 4J - was !(e->rider instanceof Player)
if (e->rider.lock() == NULL || (std::dynamic_pointer_cast<Player>(e->rider.lock())==NULL) ) // 4J - was !(e->rider instanceof Player)
{
Level::tick(e, actual);
}
@ -814,7 +814,7 @@ void ServerLevel::generateBonusItemsNearSpawn()
if( getTile( x, y, z ) == Tile::chest_Id )
{
std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(getTileEntity(x, y, z));
std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(getTileEntity(x, y, z));
if (chest != NULL)
{
if( chest->isBonusChest )
@ -1019,7 +1019,7 @@ std::shared_ptr<Explosion> ServerLevel::explode(std::shared_ptr<Entity> source,
std::vector<std::shared_ptr<ServerPlayer> > sentTo;
for(AUTO_VAR(it, players.begin()); it != players.end(); ++it)
{
std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(*it);
std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(*it);
if (player->dimension != dimension->id) continue;
bool knockbackOnly = false;
@ -1188,7 +1188,7 @@ void ServerLevel::runQueuedSendTileUpdates()
bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
{
// If its an item entity, and we've got to our capacity, delete the oldest
if( dynamic_pointer_cast<ItemEntity>(e) != NULL )
if( std::dynamic_pointer_cast<ItemEntity>(e) != NULL )
{
// printf("Adding item entity count %d\n",m_itemEntities.size());
EnterCriticalSection(&m_limiterCS);
@ -1200,7 +1200,7 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
LeaveCriticalSection(&m_limiterCS);
}
// If its an hanging entity, and we've got to our capacity, delete the oldest
else if( dynamic_pointer_cast<HangingEntity>(e) != NULL )
else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL )
{
// printf("Adding item entity count %d\n",m_itemEntities.size());
EnterCriticalSection(&m_limiterCS);
@ -1217,7 +1217,7 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
LeaveCriticalSection(&m_limiterCS);
}
// If its an arrow entity, and we've got to our capacity, delete the oldest
else if( dynamic_pointer_cast<Arrow>(e) != NULL )
else if( std::dynamic_pointer_cast<Arrow>(e) != NULL )
{
// printf("Adding arrow entity count %d\n",m_arrowEntities.size());
EnterCriticalSection(&m_limiterCS);
@ -1229,7 +1229,7 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
LeaveCriticalSection(&m_limiterCS);
}
// If its an experience orb entity, and we've got to our capacity, delete the oldest
else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
{
// printf("Adding arrow entity count %d\n",m_arrowEntities.size());
EnterCriticalSection(&m_limiterCS);
@ -1246,41 +1246,41 @@ bool ServerLevel::addEntity(std::shared_ptr<Entity> e)
// Maintain a cound of primed tnt & falling tiles in this level
void ServerLevel::entityAddedExtra(std::shared_ptr<Entity> e)
{
if( dynamic_pointer_cast<ItemEntity>(e) != NULL )
if( std::dynamic_pointer_cast<ItemEntity>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
m_itemEntities.push_back(e);
// printf("entity added: item entity count now %d\n",m_itemEntities.size());
LeaveCriticalSection(&m_limiterCS);
}
else if( dynamic_pointer_cast<HangingEntity>(e) != NULL )
else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
m_hangingEntities.push_back(e);
// printf("entity added: item entity count now %d\n",m_itemEntities.size());
LeaveCriticalSection(&m_limiterCS);
}
else if( dynamic_pointer_cast<Arrow>(e) != NULL )
else if( std::dynamic_pointer_cast<Arrow>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
m_arrowEntities.push_back(e);
// printf("entity added: arrow entity count now %d\n",m_arrowEntities.size());
LeaveCriticalSection(&m_limiterCS);
}
else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
m_experienceOrbEntities.push_back(e);
// printf("entity added: experience orb entity count now %d\n",m_arrowEntities.size());
LeaveCriticalSection(&m_limiterCS);
}
else if( dynamic_pointer_cast<PrimedTnt>(e) != NULL )
else if( std::dynamic_pointer_cast<PrimedTnt>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
m_primedTntCount++;
LeaveCriticalSection(&m_limiterCS);
}
else if( dynamic_pointer_cast<FallingTile>(e) != NULL )
else if( std::dynamic_pointer_cast<FallingTile>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
m_fallingTileCount++;
@ -1291,7 +1291,7 @@ void ServerLevel::entityAddedExtra(std::shared_ptr<Entity> e)
// Maintain a cound of primed tnt & falling tiles in this level, and remove any item entities from our list
void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e)
{
if( dynamic_pointer_cast<ItemEntity>(e) != NULL )
if( std::dynamic_pointer_cast<ItemEntity>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
// printf("entity removed: item entity count %d\n",m_itemEntities.size());
@ -1304,7 +1304,7 @@ void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e)
// printf("entity removed: item entity count now %d\n",m_itemEntities.size());
LeaveCriticalSection(&m_limiterCS);
}
else if( dynamic_pointer_cast<HangingEntity>(e) != NULL )
else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
// printf("entity removed: item entity count %d\n",m_itemEntities.size());
@ -1317,7 +1317,7 @@ void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e)
// printf("entity removed: item entity count now %d\n",m_itemEntities.size());
LeaveCriticalSection(&m_limiterCS);
}
else if( dynamic_pointer_cast<Arrow>(e) != NULL )
else if( std::dynamic_pointer_cast<Arrow>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
// printf("entity removed: arrow entity count %d\n",m_arrowEntities.size());
@ -1330,7 +1330,7 @@ void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e)
// printf("entity removed: arrow entity count now %d\n",m_arrowEntities.size());
LeaveCriticalSection(&m_limiterCS);
}
else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
// printf("entity removed: experience orb entity count %d\n",m_arrowEntities.size());
@ -1343,13 +1343,13 @@ void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e)
// printf("entity removed: experience orb entity count now %d\n",m_arrowEntities.size());
LeaveCriticalSection(&m_limiterCS);
}
else if( dynamic_pointer_cast<PrimedTnt>(e) != NULL )
else if( std::dynamic_pointer_cast<PrimedTnt>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
m_primedTntCount--;
LeaveCriticalSection(&m_limiterCS);
}
else if( dynamic_pointer_cast<FallingTile>(e) != NULL )
else if( std::dynamic_pointer_cast<FallingTile>(e) != NULL )
{
EnterCriticalSection(&m_limiterCS);
m_fallingTileCount--;

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

@ -48,7 +48,7 @@ void ServerLevelListener::entityRemoved(std::shared_ptr<Entity> entity)
// 4J added
void ServerLevelListener::playerRemoved(std::shared_ptr<Entity> entity)
{
std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(entity);
std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(entity);
player->getLevel()->getTracker()->removePlayer(entity);
}
@ -76,7 +76,7 @@ void ServerLevelListener::playSound(std::shared_ptr<Entity> entity,int iSound, d
{
// 4J-PB - I don't want to broadcast player sounds to my local machine, since we're already playing these in the LevelRenderer::playSound.
// The PC version does seem to do this and the result is I can stop walking , and then I'll hear my footstep sound with a delay
std::shared_ptr<Player> player= dynamic_pointer_cast<Player>(entity);
std::shared_ptr<Player> player= std::dynamic_pointer_cast<Player>(entity);
server->getPlayers()->broadcast(player,x, y, z, volume > 1 ? 16 * volume : 16, level->dimension->id, std::shared_ptr<LevelSoundPacket>(new LevelSoundPacket(iSound, x, y, z, volume, pitch)));
}
}

52
Minecraft.Client/Minecraft.cpp
View file

@ -2723,7 +2723,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
{
default:
{
std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
{
@ -2752,7 +2752,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break;
default:
{
std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
{
@ -2783,13 +2783,13 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
case Item::shears_Id:
{
if(player->isAllowedToAttackAnimals()) *piAction=IDS_TOOLTIPS_HIT;
std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
if(!animal->isBaby()) *piUse=IDS_TOOLTIPS_SHEAR;
}
break;
default:
{
std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
{
@ -2811,7 +2811,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
*piAction=IDS_TOOLTIPS_MINE;
// are we in the boat already?
if (dynamic_pointer_cast<Boat>( player->riding ) != NULL)
if (std::dynamic_pointer_cast<Boat>( player->riding ) != NULL)
{
*piUse=IDS_TOOLTIPS_EXIT;
}
@ -2823,13 +2823,13 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
case eTYPE_MINECART:
*piAction=IDS_TOOLTIPS_MINE;
// are we in the minecart already?
if (dynamic_pointer_cast<Minecart>( player->riding ) != NULL)
if (std::dynamic_pointer_cast<Minecart>( player->riding ) != NULL)
{
*piUse=IDS_TOOLTIPS_EXIT;
}
else
{
switch(dynamic_pointer_cast<Minecart>(hitResult->entity)->type)
switch(std::dynamic_pointer_cast<Minecart>(hitResult->entity)->type)
{
case Minecart::RIDEABLE:
*piUse=IDS_TOOLTIPS_RIDE;
@ -2871,7 +2871,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
{
case Item::dye_powder_Id:
{
std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(hitResult->entity);
std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(hitResult->entity);
// convert to tile-based color value (0 is white instead of black)
int newColor = ClothTile::getTileDataForItemAuxValue(heldItem->getAuxValue());
@ -2884,7 +2884,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break;
case Item::shears_Id:
{
std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(hitResult->entity);
std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(hitResult->entity);
// can only shear a sheep that hasn't been sheared
if(!sheep->isSheared() )
@ -2896,7 +2896,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break;
default:
{
std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
{
@ -2911,18 +2911,18 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
case eTYPE_PIG:
// can ride a pig
if(player->isAllowedToAttackAnimals()) *piAction=IDS_TOOLTIPS_HIT;
if (dynamic_pointer_cast<Pig>( player->riding ) != NULL)
if (std::dynamic_pointer_cast<Pig>( player->riding ) != NULL)
{
*piUse=IDS_TOOLTIPS_EXIT;
}
else
{
// does the pig have a saddle?
if(dynamic_pointer_cast<Pig>(hitResult->entity)->hasSaddle())
if(std::dynamic_pointer_cast<Pig>(hitResult->entity)->hasSaddle())
{
*piUse=IDS_TOOLTIPS_RIDE;
}
else if (!dynamic_pointer_cast<Pig>(hitResult->entity)->isBaby())
else if (!std::dynamic_pointer_cast<Pig>(hitResult->entity)->isBaby())
{
if(player->inventory->IsHeldItem())
{
@ -2936,7 +2936,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break;
default:
{
std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity);
std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity);
if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem))
{
@ -2955,7 +2955,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
{
int iID=-1;
std::shared_ptr<ItemInstance> heldItem=nullptr;
std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(hitResult->entity);
std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(hitResult->entity);
if(player->inventory->IsHeldItem())
{
@ -3045,7 +3045,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
{
int iID=-1;
std::shared_ptr<ItemInstance> heldItem=nullptr;
std::shared_ptr<Ozelot> ocelot = dynamic_pointer_cast<Ozelot>(hitResult->entity);
std::shared_ptr<Ozelot> ocelot = std::dynamic_pointer_cast<Ozelot>(hitResult->entity);
if(player->inventory->IsHeldItem())
{
@ -3106,7 +3106,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
case eTYPE_PLAYER:
{
// Fix for #58576 - TU6: Content: Gameplay: Hit button prompt is available when attacking a host who has "Invisible" option turned on
std::shared_ptr<Player> TargetPlayer = dynamic_pointer_cast<Player>(hitResult->entity);
std::shared_ptr<Player> TargetPlayer = std::dynamic_pointer_cast<Player>(hitResult->entity);
if(!TargetPlayer->hasInvisiblePrivilege()) // This means they are invisible, not just that they have the privilege
{
@ -3119,7 +3119,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break;
case eTYPE_ITEM_FRAME:
{
std::shared_ptr<ItemFrame> itemFrame = dynamic_pointer_cast<ItemFrame>(hitResult->entity);
std::shared_ptr<ItemFrame> itemFrame = std::dynamic_pointer_cast<ItemFrame>(hitResult->entity);
// is the frame occupied?
if(itemFrame->getItem()!=NULL)
@ -3141,7 +3141,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break;
case eTYPE_VILLAGER:
{
std::shared_ptr<Villager> villager = dynamic_pointer_cast<Villager>(hitResult->entity);
std::shared_ptr<Villager> villager = std::dynamic_pointer_cast<Villager>(hitResult->entity);
if (!villager->isBaby())
{
*piUse=IDS_TOOLTIPS_TRADE;
@ -3151,7 +3151,7 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
break;
case eTYPE_ZOMBIE:
{
std::shared_ptr<Zombie> zomb = dynamic_pointer_cast<Zombie>(hitResult->entity);
std::shared_ptr<Zombie> zomb = std::dynamic_pointer_cast<Zombie>(hitResult->entity);
std::shared_ptr<ItemInstance> heldItem=nullptr;
if(player->inventory->IsHeldItem())
@ -3337,9 +3337,9 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
if((player->ullButtonsPressed&(1LL<<MINECRAFT_ACTION_SPAWN_CREEPER)) && app.GetMobsDontAttackEnabled())
{
//std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(Creeper::_class->newInstance( level ));
//std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(std::shared_ptr<Spider>(new Spider( level )));
//std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(Creeper::_class->newInstance( level ));
//std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level ));
std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(std::shared_ptr<Spider>(new Spider( level )));
mob->moveTo(player->x+1, player->y, player->z+1, level->random->nextFloat() * 360, 0);
level->addEntity(mob);
}
@ -3369,14 +3369,14 @@ void Minecraft::tick(bool bFirst, bool bUpdateTextures)
if((player->ullButtonsPressed&(1LL<<MINECRAFT_ACTION_INVENTORY)) && gameMode->isInputAllowed(MINECRAFT_ACTION_INVENTORY))
{
std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player );
std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player );
ui.PlayUISFX(eSFX_Press);
app.LoadInventoryMenu(iPad,player);
}
if((player->ullButtonsPressed&(1LL<<MINECRAFT_ACTION_CRAFTING)) && gameMode->isInputAllowed(MINECRAFT_ACTION_CRAFTING))
{
std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player );
std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player );
// 4J-PB - reordered the if statement so creative mode doesn't bring up the crafting table
// Fix for #39014 - TU5: Creative Mode: Pressing X to access the creative menu while looking at a crafting table causes the crafting menu to display
@ -4559,7 +4559,7 @@ bool mayUse = true;
if(button==1 && (player->isSleeping() && level != NULL && level->isClientSide))
{
std::shared_ptr<MultiplayerLocalPlayer> mplp = dynamic_pointer_cast<MultiplayerLocalPlayer>( player );
std::shared_ptr<MultiplayerLocalPlayer> mplp = std::dynamic_pointer_cast<MultiplayerLocalPlayer>( player );
if(mplp) mplp->StopSleeping();

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);
eINSTANCEOF factory = (eINSTANCEOF)((size_t)param);
std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(factory,player->level ));
std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(factory,player->level ));
mob->moveTo(player->x+1, player->y, player->z+1, player->level->random->nextFloat() * 360, 0);
mob->setDespawnProtected(); // 4J added, default to being protected against despawning (has to be done after initial position is set)
player->level->addEntity(mob);

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)
{
std::shared_ptr<FishingHook> hook = std::shared_ptr<FishingHook>( new FishingHook(level, x, y, z, player) );
@ -547,7 +547,7 @@ void ClientConnection::handleAddEntity(std::shared_ptr<AddEntityPacket> packet)
}
}
}
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(owner);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(owner);
if (player != NULL)
{
std::shared_ptr<FishingHook> hook = std::shared_ptr<FishingHook>( new FishingHook(level, x, y, z, player) );
@ -653,9 +653,9 @@ void ClientConnection::handleAddEntity(std::shared_ptr<AddEntityPacket> packet)
}
}
if (dynamic_pointer_cast<Mob>(owner) != NULL)
if (std::dynamic_pointer_cast<Mob>(owner) != NULL)
{
dynamic_pointer_cast<Arrow>(e)->owner = dynamic_pointer_cast<Mob>(owner);
std::dynamic_pointer_cast<Arrow>(e)->owner = std::dynamic_pointer_cast<Mob>(owner);
}
}
@ -1201,7 +1201,7 @@ void ClientConnection::send(std::shared_ptr<Packet> packet)
void ClientConnection::handleTakeItemEntity(std::shared_ptr<TakeItemEntityPacket> packet)
{
std::shared_ptr<Entity> from = getEntity(packet->itemId);
std::shared_ptr<Mob> to = dynamic_pointer_cast<Mob>(getEntity(packet->playerId));
std::shared_ptr<Mob> to = std::dynamic_pointer_cast<Mob>(getEntity(packet->playerId));
// 4J - the original game could assume that if getEntity didn't find the player, it must be the local player. We
// need to search all local players
@ -1234,7 +1234,7 @@ void ClientConnection::handleTakeItemEntity(std::shared_ptr<TakeItemEntityPacket
// "from" reference if we've already removed the item for an earlier processed connection
if( isLocalPlayer )
{
std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>(to);
std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>(to);
// 4J Stu - Fix for #10213 - UI: Local clients cannot progress through the tutorial normally.
// We only send this packet once if many local players can see the event, so make sure we update
@ -1565,7 +1565,7 @@ void ClientConnection::handleAnimate(std::shared_ptr<AnimatePacket> packet)
if (e == NULL) return;
if (packet->action == AnimatePacket::SWING)
{
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
if(player != NULL) player->swing();
}
else if (packet->action == AnimatePacket::HURT)
@ -1574,7 +1574,7 @@ void ClientConnection::handleAnimate(std::shared_ptr<AnimatePacket> packet)
}
else if (packet->action == AnimatePacket::WAKE_UP)
{
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
if(player != NULL) player->stopSleepInBed(false, false, false);
}
else if (packet->action == AnimatePacket::RESPAWN)
@ -1592,7 +1592,7 @@ void ClientConnection::handleAnimate(std::shared_ptr<AnimatePacket> packet)
critParticle->CritParticlePostConstructor();
minecraft->particleEngine->add(critParticle);
}
else if (packet->action == AnimatePacket::EAT && dynamic_pointer_cast<RemotePlayer>(e) != NULL)
else if (packet->action == AnimatePacket::EAT && std::dynamic_pointer_cast<RemotePlayer>(e) != NULL)
{
}
@ -1604,7 +1604,7 @@ void ClientConnection::handleEntityActionAtPosition(std::shared_ptr<EntityAction
if (e == NULL) return;
if (packet->action == EntityActionAtPositionPacket::START_SLEEP)
{
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
player->startSleepInBed(packet->x, packet->y, packet->z);
if( player == minecraft->localplayers[m_userIndex] )
@ -2110,7 +2110,7 @@ void ClientConnection::handleAddMob(std::shared_ptr<AddMobPacket> packet)
float yRot = packet->yRot * 360 / 256.0f;
float xRot = packet->xRot * 360 / 256.0f;
std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(EntityIO::newById(packet->type, level));
std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(EntityIO::newById(packet->type, level));
mob->xp = packet->x;
mob->yp = packet->y;
mob->zp = packet->z;
@ -2150,7 +2150,7 @@ void ClientConnection::handleAddMob(std::shared_ptr<AddMobPacket> packet)
// 4J Stu - Slimes have a different BB depending on their size which is set in the entity data, so update the BB
if(mob->GetType() == eTYPE_SLIME || mob->GetType() == eTYPE_LAVASLIME)
{
std::shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(mob);
std::shared_ptr<Slime> slime = std::dynamic_pointer_cast<Slime>(mob);
slime->setSize( slime->getSize() );
}
}
@ -2173,7 +2173,7 @@ void ClientConnection::handleRidePacket(std::shared_ptr<SetRidingPacket> packet)
std::shared_ptr<Entity> rider = getEntity(packet->riderId);
std::shared_ptr<Entity> ridden = getEntity(packet->riddenId);
std::shared_ptr<Boat> boat = dynamic_pointer_cast<Boat>(ridden);
std::shared_ptr<Boat> boat = std::dynamic_pointer_cast<Boat>(ridden);
//if (packet->riderId == minecraft->player->entityId) rider = minecraft->player;
if (packet->riderId == minecraft->localplayers[m_userIndex]->entityId)
{
@ -2324,7 +2324,7 @@ void ClientConnection::handleTextureChange(std::shared_ptr<TextureChangePacket>
{
std::shared_ptr<Entity> e = getEntity(packet->id);
if (e == NULL) return;
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
if( e == NULL) return;
bool isLocalPlayer = false;
@ -2379,7 +2379,7 @@ void ClientConnection::handleTextureAndGeometryChange(std::shared_ptr<TextureAnd
{
std::shared_ptr<Entity> e = getEntity(packet->id);
if (e == NULL) return;
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
if( e == NULL) return;
bool isLocalPlayer = false;
@ -2762,9 +2762,9 @@ void ClientConnection::handleSignUpdate(std::shared_ptr<SignUpdatePacket> packet
std::shared_ptr<TileEntity> te = minecraft->level->getTileEntity(packet->x, packet->y, packet->z);
// 4J-PB - on a client connecting, the line below fails
if (dynamic_pointer_cast<SignTileEntity>(te) != NULL)
if (std::dynamic_pointer_cast<SignTileEntity>(te) != NULL)
{
std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>(te);
std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>(te);
for (int i = 0; i < MAX_SIGN_LINES; i++)
{
ste->SetMessage(i,packet->lines[i]);
@ -2778,7 +2778,7 @@ void ClientConnection::handleSignUpdate(std::shared_ptr<SignUpdatePacket> packet
}
else
{
app.DebugPrintf("dynamic_pointer_cast<SignTileEntity>(te) == NULL\n");
app.DebugPrintf("std::dynamic_pointer_cast<SignTileEntity>(te) == NULL\n");
}
}
else
@ -2795,9 +2795,9 @@ void ClientConnection::handleTileEntityData(std::shared_ptr<TileEntityDataPacket
if (te != NULL)
{
if (packet->type == TileEntityDataPacket::TYPE_MOB_SPAWNER && dynamic_pointer_cast<MobSpawnerTileEntity>(te) != NULL)
if (packet->type == TileEntityDataPacket::TYPE_MOB_SPAWNER && std::dynamic_pointer_cast<MobSpawnerTileEntity>(te) != NULL)
{
dynamic_pointer_cast<MobSpawnerTileEntity>(te)->load(packet->tag);
std::dynamic_pointer_cast<MobSpawnerTileEntity>(te)->load(packet->tag);
}
//else if (packet.type == TileEntityDataPacket.TYPE_ADV_COMMAND && (te instanceof CommandBlockEntity))
//{
@ -2807,9 +2807,9 @@ void ClientConnection::handleTileEntityData(std::shared_ptr<TileEntityDataPacket
//{
// ((BeaconTileEntity) te).load(packet.tag);
//}
else if (packet->type == TileEntityDataPacket::TYPE_SKULL && dynamic_pointer_cast<SkullTileEntity>(te) != NULL)
else if (packet->type == TileEntityDataPacket::TYPE_SKULL && std::dynamic_pointer_cast<SkullTileEntity>(te) != NULL)
{
dynamic_pointer_cast<SkullTileEntity>(te)->load(packet->tag);
std::dynamic_pointer_cast<SkullTileEntity>(te)->load(packet->tag);
}
}
}
@ -2968,17 +2968,17 @@ void ClientConnection::handleAwardStat(std::shared_ptr<AwardStatPacket> packet)
void ClientConnection::handleUpdateMobEffect(std::shared_ptr<UpdateMobEffectPacket> packet)
{
std::shared_ptr<Entity> e = getEntity(packet->entityId);
if (e == NULL || dynamic_pointer_cast<Mob>(e) == NULL) return;
if (e == NULL || std::dynamic_pointer_cast<Mob>(e) == NULL) return;
( dynamic_pointer_cast<Mob>(e) )->addEffect(new MobEffectInstance(packet->effectId, packet->effectDurationTicks, packet->effectAmplifier));
( std::dynamic_pointer_cast<Mob>(e) )->addEffect(new MobEffectInstance(packet->effectId, packet->effectDurationTicks, packet->effectAmplifier));
}
void ClientConnection::handleRemoveMobEffect(std::shared_ptr<RemoveMobEffectPacket> packet)
{
std::shared_ptr<Entity> e = getEntity(packet->entityId);
if (e == NULL || dynamic_pointer_cast<Mob>(e) == NULL) return;
if (e == NULL || std::dynamic_pointer_cast<Mob>(e) == NULL) return;
( dynamic_pointer_cast<Mob>(e) )->removeEffectNoUpdate(packet->effectId);
( std::dynamic_pointer_cast<Mob>(e) )->removeEffectNoUpdate(packet->effectId);
}
bool ClientConnection::isServerPacketListener()
@ -3005,7 +3005,7 @@ void ClientConnection::handlePlayerInfo(std::shared_ptr<PlayerInfoPacket> packet
std::shared_ptr<Entity> entity = getEntity(packet->m_entityId);
if(entity != NULL && entity->GetType() == eTYPE_PLAYER)
{
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(entity);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(entity);
player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_All, packet->m_playerPrivileges);
}
if(networkPlayer != NULL && networkPlayer->IsLocal())

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);
if (dynamic_pointer_cast<SignTileEntity>(te) != NULL)
if (std::dynamic_pointer_cast<SignTileEntity>(te) != NULL)
{
std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>(te);
std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>(te);
if (!ste->isEditable())
{
server->warn(L"Player " + player->name + L" just tried to change non-editable sign");
@ -1284,12 +1284,12 @@ void PlayerConnection::handleSignUpdate(std::shared_ptr<SignUpdatePacket> packet
}
// 4J-JEV: Changed to allow characters to display as a [].
if (dynamic_pointer_cast<SignTileEntity>(te) != NULL)
if (std::dynamic_pointer_cast<SignTileEntity>(te) != NULL)
{
int x = packet->x;
int y = packet->y;
int z = packet->z;
std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>(te);
std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>(te);
for (int i = 0; i < 4; i++)
{
std::wstring lineText = packet->lines[i].substr(0,15);
@ -1512,7 +1512,7 @@ void PlayerConnection::handleCustomPayload(std::shared_ptr<CustomPayloadPacket>
void PlayerConnection::handleDebugOptions(std::shared_ptr<DebugOptionsPacket> packet)
{
//Player player = dynamic_pointer_cast<Player>( player->shared_from_this() );
//Player player = std::dynamic_pointer_cast<Player>( player->shared_from_this() );
player->SetDebugOptions(packet->m_uiVal);
}
@ -1528,7 +1528,7 @@ void PlayerConnection::handleCraftItem(std::shared_ptr<CraftItemPacket> packet)
if(app.DebugSettingsOn() && (player->GetDebugOptions()&(1L<<eDebugSetting_CraftAnything)))
{
pTempItemInst->onCraftedBy(player->level, dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count );
pTempItemInst->onCraftedBy(player->level, std::dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count );
if(player->inventory->add(pTempItemInst)==false )
{
// no room in inventory, so throw it down
@ -1542,7 +1542,7 @@ void PlayerConnection::handleCraftItem(std::shared_ptr<CraftItemPacket> packet)
// TODO 4J Stu - Assume at the moment that the client can work this out for us...
//if(pRecipeIngredientsRequired[iRecipe].bCanMake)
//{
pTempItemInst->onCraftedBy(player->level, dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count );
pTempItemInst->onCraftedBy(player->level, std::dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count );
// and remove those resources from your inventory
for(int i=0;i<pRecipeIngredientsRequired[iRecipe].iIngC;i++)

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;
if( except != NULL )
{
sentTo.push_back(dynamic_pointer_cast<ServerPlayer>(except));
sentTo.push_back(std::dynamic_pointer_cast<ServerPlayer>(except));
}
for (unsigned int i = 0; i < players.size(); i++)
@ -1080,7 +1080,7 @@ void PlayerList::broadcast(std::shared_ptr<Player> except, double x, double y, d
if (xd * xd + yd * yd + zd * zd < range * range)
{
#if 0 // _DEBUG
std::shared_ptr<LevelSoundPacket> SoundPacket= dynamic_pointer_cast<LevelSoundPacket>(packet);
std::shared_ptr<LevelSoundPacket> SoundPacket= std::dynamic_pointer_cast<LevelSoundPacket>(packet);
if(SoundPacket)
{

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

@ -22,7 +22,7 @@
using std::tr1::bad_std::;
using std::tr1::const_pointer_cast;
using std::tr1::dynamic_pointer_cast;
using std::tr1::std::dynamic_pointer_cast;
using std::tr1::enable_shared_from_this;
using std::tr1::get_deleter;
using std::tr1::std::shared_ptr;

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

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.
template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
dynamic_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
std::dynamic_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
{
return boost::interprocess::offset_ptr<T1, P1, O1, A1>
(r, boost::interprocess::ipcdetail::dynamic_cast_tag());

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*/
/*
template<class T, class U, class VP>
inline boost::interprocess::intrusive_ptr<T, VP> dynamic_pointer_cast
inline boost::interprocess::intrusive_ptr<T, VP> std::dynamic_pointer_cast
(boost::interprocess::intrusive_ptr<U, VP> const & p)
{ return do_dynamic_cast<U>(p.get()); }
*/

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

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);
}
//dynamic_pointer_cast overload for raw pointers
//std::dynamic_pointer_cast overload for raw pointers
template<class T, class U>
inline T* dynamic_pointer_cast(U *ptr)
inline T* std::dynamic_pointer_cast(U *ptr)
{
return dynamic_cast<T*>(ptr);
}

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());
}
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());
}

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());
}
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());
}

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 );
}
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

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

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)
{
addEntity(e, 32 * 16, 2);
std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e);
std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e);
for( AUTO_VAR(it, entities.begin()); it != entities.end(); it++ )
{
if( (*it)->e != player )
@ -55,7 +55,7 @@ void EntityTracker::addEntity(std::shared_ptr<Entity> e)
else if (e->GetType() == eTYPE_MINECART) addEntity(e, 16 * 5, 3, true);
else if (e->GetType() == eTYPE_BOAT) addEntity(e, 16 * 5, 3, true);
else if (e->GetType() == eTYPE_SQUID) addEntity(e, 16 * 4, 3, true);
else if (dynamic_pointer_cast<Creature>(e)!=NULL) addEntity(e, 16 * 5, 3, true);
else if (std::dynamic_pointer_cast<Creature>(e)!=NULL) addEntity(e, 16 * 5, 3, true);
else if (e->GetType() == eTYPE_ENDERDRAGON ) addEntity(e, 16 * 10, 3, true);
else if (e->GetType() == eTYPE_PRIMEDTNT) addEntity(e, 16 * 10, 10, true);
else if (e->GetType() == eTYPE_FALLINGTILE) addEntity(e, 16 * 10, 20, true);
@ -105,7 +105,7 @@ void EntityTracker::removePlayer(std::shared_ptr<Entity> e)
{
if (e->GetType() == eTYPE_SERVERPLAYER)
{
std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e);
std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e);
for( AUTO_VAR(it, entities.begin()); it != entities.end(); it++ )
{
(*it)->removePlayer(player);
@ -122,7 +122,7 @@ void EntityTracker::tick()
te->tick(this, &level->players);
if (te->moved && te->e->GetType() == eTYPE_SERVERPLAYER)
{
movedPlayers.push_back(dynamic_pointer_cast<ServerPlayer>(te->e));
movedPlayers.push_back(std::dynamic_pointer_cast<ServerPlayer>(te->e));
}
}
@ -174,7 +174,7 @@ void EntityTracker::tick()
// 4J Stu - We want to do this for dead players as they don't tick normally
for(AUTO_VAR(it, level->players.begin()); it != level->players.end(); ++it)
{
std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(*it);
std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(*it);
if(!player->isAlive())
{
player->flushEntitiesToRemove();

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

@ -276,7 +276,7 @@ void LocalPlayer::aiStep()
float runTreshold = 0.8f;
bool wasRunning = input->ya >= runTreshold;
//input->tick( dynamic_pointer_cast<Player>( shared_from_this() ) );
//input->tick( std::dynamic_pointer_cast<Player>( shared_from_this() ) );
// 4J-PB - make it a localplayer
input->tick( this );
if (isUsingItem())
@ -600,7 +600,7 @@ bool LocalPlayer::openContainer(std::shared_ptr<Container> container)
bool LocalPlayer::startCrafting(int x, int y, int z)
{
bool success = app.LoadCrafting3x3Menu(GetXboxPad(), dynamic_pointer_cast<LocalPlayer>( shared_from_this() ), x, y, z );
bool success = app.LoadCrafting3x3Menu(GetXboxPad(), std::dynamic_pointer_cast<LocalPlayer>( shared_from_this() ), x, y, z );
if( success ) ui.PlayUISFX(eSFX_Press);
//app.LoadXuiCraftMenu(0,inventory, level, x, y, z);
//minecraft->setScreen(new CraftingScreen(inventory, level, x, y, z));
@ -744,7 +744,7 @@ void LocalPlayer::awardStat(Stat *stat, byteArray param)
&& ProfileManager.IsFullVersion()
)
{
stat->handleParamBlob(dynamic_pointer_cast<LocalPlayer>(shared_from_this()), param);
stat->handleParamBlob(std::dynamic_pointer_cast<LocalPlayer>(shared_from_this()), param);
}
delete [] param.data;
#else
@ -1408,7 +1408,7 @@ bool LocalPlayer::handleMouseClick(int button)
if(lastClickState == lastClick_oldRepeat) return false;
std::shared_ptr<MultiplayerLocalPlayer> mplp = dynamic_pointer_cast<MultiplayerLocalPlayer>( shared_from_this() );
std::shared_ptr<MultiplayerLocalPlayer> mplp = std::dynamic_pointer_cast<MultiplayerLocalPlayer>( shared_from_this() );
if(mplp && mplp->connection) mplp->StopSleeping();
@ -1528,15 +1528,15 @@ void LocalPlayer::updateRichPresence()
{
app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_MAP);
}
else if(riding != NULL && dynamic_pointer_cast<Minecart>(riding) != NULL)
else if(riding != NULL && std::dynamic_pointer_cast<Minecart>(riding) != NULL)
{
app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_RIDING_MINECART);
}
else if(riding != NULL && dynamic_pointer_cast<Boat>(riding) != NULL)
else if(riding != NULL && std::dynamic_pointer_cast<Boat>(riding) != NULL)
{
app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_BOATING);
}
else if(riding != NULL && dynamic_pointer_cast<Pig>(riding) != NULL)
else if(riding != NULL && std::dynamic_pointer_cast<Pig>(riding) != NULL)
{
app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_RIDING_PIG);
}

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

@ -334,9 +334,9 @@ void MultiplayerLocalPlayer::ride(std::shared_ptr<Entity> e)
}
else if (!wasRiding && isRiding)
{
if(dynamic_pointer_cast<Minecart>(e) != NULL)
if(std::dynamic_pointer_cast<Minecart>(e) != NULL)
gameMode->getTutorial()->changeTutorialState(e_Tutorial_State_Riding_Minecart);
else if(dynamic_pointer_cast<Boat>(e) != NULL)
else if(std::dynamic_pointer_cast<Boat>(e) != NULL)
gameMode->getTutorial()->changeTutorialState(e_Tutorial_State_Riding_Boat);
}
}

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

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

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

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
if (e->GetType()== eTYPE_ITEM_FRAME && tickCount % 10 == 0)
{
std::shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame> (e);
std::shared_ptr<ItemFrame> frame = std::dynamic_pointer_cast<ItemFrame> (e);
std::shared_ptr<ItemInstance> item = frame->getItem();
if (item != NULL && item->getItem()->id == Item::map_Id && !e->removed)
@ -78,7 +78,7 @@ void TrackedEntity::tick(EntityTracker *tracker, std::vector<std::shared_ptr<Pla
std::shared_ptr<MapItemSavedData> data = Item::map->getSavedData(item, e->level);
for (AUTO_VAR(it,players->begin() ); it != players->end(); ++it)
{
std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(*it);
std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(*it);
data->tickCarriedBy(player, item);
if (!player->removed && player->connection && player->connection->countDelayedPackets() <= 5)
@ -278,7 +278,7 @@ void TrackedEntity::tick(EntityTracker *tracker, std::vector<std::shared_ptr<Pla
xRotp = xRotn;
}
// if( dynamic_pointer_cast<ServerPlayer>(e) != NULL )
// if( std::dynamic_pointer_cast<ServerPlayer>(e) != NULL )
// {
// printf("%d: %d + %d = %d (%f)\n",e->entityId,xRotp,xRota,xRotn,e->xRot);
// }
@ -337,7 +337,7 @@ void TrackedEntity::broadcast(std::shared_ptr<Packet> packet)
{
dontSend = true;
// #ifdef _DEBUG
// std::shared_ptr<SetEntityMotionPacket> emp= dynamic_pointer_cast<SetEntityMotionPacket> (packet);
// std::shared_ptr<SetEntityMotionPacket> emp= std::dynamic_pointer_cast<SetEntityMotionPacket> (packet);
// if(emp!=NULL)
// {
// app.DebugPrintf("Not sending this SetEntityMotionPacket to player - it's already been sent to a player on their console\n");
@ -372,7 +372,7 @@ void TrackedEntity::broadcastAndSend(std::shared_ptr<Packet> packet)
{
std::vector< std::shared_ptr<ServerPlayer> > sentTo;
broadcast(packet);
std::shared_ptr<ServerPlayer> sp = dynamic_pointer_cast<ServerPlayer>(e);
std::shared_ptr<ServerPlayer> sp = std::dynamic_pointer_cast<ServerPlayer>(e);
if (sp != NULL && sp->connection)
{
sp->connection->send(packet);
@ -480,7 +480,7 @@ void TrackedEntity::updatePlayer(EntityTracker *tracker, std::shared_ptr<ServerP
yap = e->yd;
zap = e->zd;
std::shared_ptr<Player> plr = dynamic_pointer_cast<Player>(e);
std::shared_ptr<Player> plr = std::dynamic_pointer_cast<Player>(e);
if (plr != NULL)
{
app.DebugPrintf( "TrackedEntity:: Player '%ls' is now visible to player '%ls', %s.\n",
@ -490,7 +490,7 @@ void TrackedEntity::updatePlayer(EntityTracker *tracker, std::shared_ptr<ServerP
}
// 4J Stu brought forward to fix when Item Frames
if (!e->getEntityData()->isEmpty() && !(dynamic_pointer_cast<AddMobPacket>(packet)))
if (!e->getEntityData()->isEmpty() && !(std::dynamic_pointer_cast<AddMobPacket>(packet)))
{
sp->connection->send(std::shared_ptr<SetEntityDataPacket>( new SetEntityDataPacket(e->entityId, e->getEntityData(), true)));
}
@ -514,18 +514,18 @@ void TrackedEntity::updatePlayer(EntityTracker *tracker, std::shared_ptr<ServerP
}
}
if (dynamic_pointer_cast<Player>(e) != NULL)
if (std::dynamic_pointer_cast<Player>(e) != NULL)
{
std::shared_ptr<Player> spe = dynamic_pointer_cast<Player>(e);
std::shared_ptr<Player> spe = std::dynamic_pointer_cast<Player>(e);
if (spe->isSleeping())
{
sp->connection->send( std::shared_ptr<EntityActionAtPositionPacket>( new EntityActionAtPositionPacket(e, EntityActionAtPositionPacket::START_SLEEP, Mth::floor(e->x), Mth::floor(e->y), Mth::floor(e->z)) ) );
}
}
if (dynamic_pointer_cast<Mob>(e) != NULL)
if (std::dynamic_pointer_cast<Mob>(e) != NULL)
{
std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e);
std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(e);
std::vector<MobEffectInstance *> *activeEffects = mob->getActiveEffects();
for(AUTO_VAR(it, activeEffects->begin()); it != activeEffects->end(); ++it)
{
@ -562,7 +562,7 @@ void TrackedEntity::updatePlayers(EntityTracker *tracker, std::vector<std::share
{
for (unsigned int i = 0; i < players->size(); i++)
{
updatePlayer(tracker, dynamic_pointer_cast<ServerPlayer>( players->at(i) ) );
updatePlayer(tracker, std::dynamic_pointer_cast<ServerPlayer>( players->at(i) ) );
}
}
@ -574,10 +574,10 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
}
// 4J-PB - replacing with a switch, rather than tons of ifs
if (dynamic_pointer_cast<Creature>(e) != NULL)
if (std::dynamic_pointer_cast<Creature>(e) != NULL)
{
yHeadRotp = Mth::floor(e->getYHeadRot() * 256 / 360);
return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp) );
return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp) );
}
switch(e->GetType())
@ -590,7 +590,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break;
case eTYPE_SERVERPLAYER:
{
std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e);
std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e);
PlayerUID xuid = INVALID_XUID;
PlayerUID OnlineXuid = INVALID_XUID;
if( player != NULL )
@ -599,12 +599,12 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
OnlineXuid = player->getOnlineXuid();
}
// 4J Added yHeadRotp param to fix #102563 - TU12: Content: Gameplay: When one of the Players is idle for a few minutes his head turns 180 degrees.
return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp, yHeadRotp ) );
return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(std::dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp, yHeadRotp ) );
}
break;
case eTYPE_MINECART:
{
std::shared_ptr<Minecart> minecart = dynamic_pointer_cast<Minecart>(e);
std::shared_ptr<Minecart> minecart = std::dynamic_pointer_cast<Minecart>(e);
if (minecart->type == Minecart::RIDEABLE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_RIDEABLE, yRotp, xRotp, xp, yp, zp) );
if (minecart->type == Minecart::CHEST) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_CHEST, yRotp, xRotp, xp, yp, zp) );
if (minecart->type == Minecart::FURNACE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_FURNACE, yRotp, xRotp, xp, yp, zp) );
@ -618,18 +618,18 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
case eTYPE_ENDERDRAGON:
{
yHeadRotp = Mth::floor(e->getYHeadRot() * 256 / 360);
return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp ) );
return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp ) );
}
break;
case eTYPE_FISHINGHOOK:
{
std::shared_ptr<Entity> owner = dynamic_pointer_cast<FishingHook>(e)->owner;
std::shared_ptr<Entity> owner = std::dynamic_pointer_cast<FishingHook>(e)->owner;
return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FISH_HOOK, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
}
break;
case eTYPE_ARROW:
{
std::shared_ptr<Entity> owner = (dynamic_pointer_cast<Arrow>(e))->owner;
std::shared_ptr<Entity> owner = (std::dynamic_pointer_cast<Arrow>(e))->owner;
return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ARROW, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
}
break;
@ -640,7 +640,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break;
case eTYPE_THROWNPOTION:
{
return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp));
return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((std::dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp));
}
break;
case eTYPE_THROWNEXPBOTTLE:
@ -660,7 +660,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break;
case eTYPE_SMALL_FIREBALL:
{
std::shared_ptr<SmallFireball> fb = dynamic_pointer_cast<SmallFireball>(e);
std::shared_ptr<SmallFireball> fb = std::dynamic_pointer_cast<SmallFireball>(e);
std::shared_ptr<AddEntityPacket> aep = nullptr;
if (fb->owner != NULL)
{
@ -678,7 +678,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break;
case eTYPE_DRAGON_FIREBALL:
{
std::shared_ptr<DragonFireball> fb = dynamic_pointer_cast<DragonFireball>(e);
std::shared_ptr<DragonFireball> fb = std::dynamic_pointer_cast<DragonFireball>(e);
std::shared_ptr<AddEntityPacket> aep = nullptr;
if (fb->owner != NULL)
{
@ -696,7 +696,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break;
case eTYPE_FIREBALL:
{
std::shared_ptr<Fireball> fb = dynamic_pointer_cast<Fireball>(e);
std::shared_ptr<Fireball> fb = std::dynamic_pointer_cast<Fireball>(e);
std::shared_ptr<AddEntityPacket> aep = nullptr;
if (fb->owner != NULL)
{
@ -729,18 +729,18 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break;
case eTYPE_FALLINGTILE:
{
std::shared_ptr<FallingTile> ft = dynamic_pointer_cast<FallingTile>(e);
std::shared_ptr<FallingTile> ft = std::dynamic_pointer_cast<FallingTile>(e);
return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING, ft->tile | (ft->data << 16), yRotp, xRotp, xp, yp, zp) );
}
break;
case eTYPE_PAINTING:
{
return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(dynamic_pointer_cast<Painting>(e)) );
return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(std::dynamic_pointer_cast<Painting>(e)) );
}
break;
case eTYPE_ITEM_FRAME:
{
std::shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame>(e);
std::shared_ptr<ItemFrame> frame = std::dynamic_pointer_cast<ItemFrame>(e);
{
int ix= (int)frame->xTile;
@ -758,7 +758,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
break;
case eTYPE_EXPERIENCEORB:
{
return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(dynamic_pointer_cast<ExperienceOrb>(e)) );
return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(std::dynamic_pointer_cast<ExperienceOrb>(e)) );
}
break;
default:
@ -768,7 +768,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
/*
if (e->GetType() == eTYPE_ITEMENTITY)
{
std::shared_ptr<ItemEntity> itemEntity = dynamic_pointer_cast<ItemEntity>(e);
std::shared_ptr<ItemEntity> itemEntity = std::dynamic_pointer_cast<ItemEntity>(e);
std::shared_ptr<AddItemEntityPacket> packet = std::shared_ptr<AddItemEntityPacket>( new AddItemEntityPacket(itemEntity, xp, yp, zp) );
itemEntity->x = packet->x / 32.0;
itemEntity->y = packet->y / 32.0;
@ -778,7 +778,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
if (e->GetType() == eTYPE_SERVERPLAYER )
{
std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e);
std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e);
XUID xuid = INVALID_XUID;
XUID OnlineXuid = INVALID_XUID;
if( player != NULL )
@ -786,11 +786,11 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
xuid = player->getXuid();
OnlineXuid = player->getOnlineXuid();
}
return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp ) );
return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(std::dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp ) );
}
if (e->GetType() == eTYPE_MINECART)
{
std::shared_ptr<Minecart> minecart = dynamic_pointer_cast<Minecart>(e);
std::shared_ptr<Minecart> minecart = std::dynamic_pointer_cast<Minecart>(e);
if (minecart->type == Minecart::RIDEABLE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_RIDEABLE, yRotp, xRotp, xp, yp, zp) );
if (minecart->type == Minecart::CHEST) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_CHEST, yRotp, xRotp, xp, yp, zp) );
if (minecart->type == Minecart::FURNACE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_FURNACE, yRotp, xRotp, xp, yp, zp) );
@ -799,22 +799,22 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
{
return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::BOAT, yRotp, xRotp, xp, yp, zp) );
}
if (dynamic_pointer_cast<Creature>(e) != NULL)
if (std::dynamic_pointer_cast<Creature>(e) != NULL)
{
return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp) );
return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp) );
}
if (e->GetType() == eTYPE_ENDERDRAGON)
{
return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp ) );
return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp ) );
}
if (e->GetType() == eTYPE_FISHINGHOOK)
{
std::shared_ptr<Entity> owner = dynamic_pointer_cast<FishingHook>(e)->owner;
std::shared_ptr<Entity> owner = std::dynamic_pointer_cast<FishingHook>(e)->owner;
return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FISH_HOOK, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
}
if (e->GetType() == eTYPE_ARROW)
{
std::shared_ptr<Entity> owner = (dynamic_pointer_cast<Arrow>(e))->owner;
std::shared_ptr<Entity> owner = (std::dynamic_pointer_cast<Arrow>(e))->owner;
return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ARROW, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
}
if (e->GetType() == eTYPE_SNOWBALL)
@ -823,7 +823,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
}
if (e->GetType() == eTYPE_THROWNPOTION)
{
return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp));
return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((std::dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp));
}
if (e->GetType() == eTYPE_THROWNEXPBOTTLE)
{
@ -839,7 +839,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
}
if (e->GetType() == eTYPE_SMALL_FIREBALL)
{
std::shared_ptr<SmallFireball> fb = dynamic_pointer_cast<SmallFireball>(e);
std::shared_ptr<SmallFireball> fb = std::dynamic_pointer_cast<SmallFireball>(e);
std::shared_ptr<AddEntityPacket> aep = NULL;
if (fb->owner != NULL)
{
@ -856,7 +856,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
}
if (e->GetType() == eTYPE_FIREBALL)
{
std::shared_ptr<Fireball> fb = dynamic_pointer_cast<Fireball>(e);
std::shared_ptr<Fireball> fb = std::dynamic_pointer_cast<Fireball>(e);
std::shared_ptr<AddEntityPacket> aep = NULL;
if (fb->owner != NULL)
{
@ -885,18 +885,18 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
}
if (e->GetType() == eTYPE_FALLINGTILE)
{
std::shared_ptr<FallingTile> ft = dynamic_pointer_cast<FallingTile>(e);
std::shared_ptr<FallingTile> ft = std::dynamic_pointer_cast<FallingTile>(e);
if (ft->tile == Tile::sand_Id) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_SAND, yRotp, xRotp, xp, yp, zp) );
if (ft->tile == Tile::gravel_Id) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_GRAVEL, yRotp, xRotp, xp, yp, zp) );
if (ft->tile == Tile::dragonEgg_Id) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_EGG, yRotp, xRotp, xp, yp, zp) );
}
if (e->GetType() == eTYPE_PAINTING)
{
return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(dynamic_pointer_cast<Painting>(e)) );
return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(std::dynamic_pointer_cast<Painting>(e)) );
}
if (e->GetType() == eTYPE_ITEM_FRAME)
{
std::shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame>(e);
std::shared_ptr<ItemFrame> frame = std::dynamic_pointer_cast<ItemFrame>(e);
{
int ix= (int)frame->xTile;
@ -913,7 +913,7 @@ std::shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
}
if (e->GetType() == eTYPE_EXPERIENCEORB)
{
return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(dynamic_pointer_cast<ExperienceOrb>(e)) );
return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(std::dynamic_pointer_cast<ExperienceOrb>(e)) );
}
assert(false);
*/

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 -
// do some casting around instead
std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(_arrow);
std::shared_ptr<Arrow> arrow = std::dynamic_pointer_cast<Arrow>(_arrow);
bindTexture(TN_ITEM_ARROWS); // 4J - was L"/item/arrows.png"
glPushMatrix();

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 -
// do some casting around instead
std::shared_ptr<Blaze> mob = dynamic_pointer_cast<Blaze>(_mob);
std::shared_ptr<Blaze> mob = std::dynamic_pointer_cast<Blaze>(_mob);
int modelVersion = ((BlazeModel *) model)->modelVersion();
if (modelVersion != this->modelVersion)

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

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)
{
// 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;

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

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)
{
std::shared_ptr<Creeper> creeper = dynamic_pointer_cast<Creeper>(mob);
std::shared_ptr<Creeper> creeper = std::dynamic_pointer_cast<Creeper>(mob);
float g = creeper->getSwelling(a);
@ -27,7 +27,7 @@ void CreeperRenderer::scale(std::shared_ptr<Mob> mob, float a)
int CreeperRenderer::getOverlayColor(std::shared_ptr<Mob> mob, float br, float a)
{
std::shared_ptr<Creeper> creeper = dynamic_pointer_cast<Creeper>(mob);
std::shared_ptr<Creeper> creeper = std::dynamic_pointer_cast<Creeper>(mob);
float step = creeper->getSwelling(a);
@ -47,7 +47,7 @@ int CreeperRenderer::getOverlayColor(std::shared_ptr<Mob> mob, float br, float a
int CreeperRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Creeper> mob = dynamic_pointer_cast<Creeper>(_mob);
std::shared_ptr<Creeper> mob = std::dynamic_pointer_cast<Creeper>(_mob);
if (mob->isPowered())
{
if (mob->isInvisible()) glDepthMask(false);

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)
{
// 4J Convert as we aren't using a templated class
std::shared_ptr<EnchantmentTableEntity> table = dynamic_pointer_cast<EnchantmentTableEntity>(_table);
std::shared_ptr<EnchantmentTableEntity> table = std::dynamic_pointer_cast<EnchantmentTableEntity>(_table);
#ifdef __PSVITA__
// AP - the book pages are made with 0 depth so the front and back polys are at the same location. This can cause z-fighting if culling is disabled which can sometimes happen

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)
{
// 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;

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 -
// do some casting around instead
std::shared_ptr<EnderCrystal> crystal = dynamic_pointer_cast<EnderCrystal>(_crystal);
std::shared_ptr<EnderCrystal> crystal = std::dynamic_pointer_cast<EnderCrystal>(_crystal);
if (currentModel != EnderCrystalModel::MODEL_ID)
{
model = new EnderCrystalModel(0);

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob);
// 4J - reorganised a bit so we can free allocations
double lpComponents[3];
@ -49,7 +49,7 @@ void EnderDragonRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, f
void EnderDragonRenderer::renderModel(std::shared_ptr<Entity> _mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob);
if (mob->dragonDeathTime > 0)
{
@ -90,7 +90,7 @@ void EnderDragonRenderer::renderModel(std::shared_ptr<Entity> _mob, float wp, fl
void EnderDragonRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob);
EnderDragonRenderer::bossInstance = mob;
if (currentModel != DragonModel::MODEL_ID)
{
@ -170,7 +170,7 @@ void EnderDragonRenderer::render(std::shared_ptr<Entity> _mob, double x, double
void EnderDragonRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob);
MobRenderer::additionalRendering(mob, a);
Tesselator *t = Tesselator::getInstance();
@ -230,7 +230,7 @@ void EnderDragonRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a
int EnderDragonRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob);
if (layer == 1)
{

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 -
// do some casting around instead
std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
std::shared_ptr<EnderMan> mob = std::dynamic_pointer_cast<EnderMan>(_mob);
model->carrying = mob->getCarryingTile() > 0;
model->creepy = mob->isCreepy();
@ -33,7 +33,7 @@ void EndermanRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
{
// 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
std::shared_ptr<EnderMan> mob = std::dynamic_pointer_cast<EnderMan>(_mob);
MobRenderer::additionalRendering(_mob, a);
@ -72,7 +72,7 @@ int EndermanRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a
{
// 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
std::shared_ptr<EnderMan> mob = std::dynamic_pointer_cast<EnderMan>(_mob);
if (layer != 0) return -1;

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;
}
std::shared_ptr<Player> pl = dynamic_pointer_cast<Player>(player);
std::shared_ptr<Player> pl = std::dynamic_pointer_cast<Player>(player);
if (pl->ThirdPersonView() == 2)
{
playerRotY += 180;

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

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)
{
std::shared_ptr<ExperienceOrb> orb = dynamic_pointer_cast<ExperienceOrb>(_orb);
std::shared_ptr<ExperienceOrb> orb = std::dynamic_pointer_cast<ExperienceOrb>(_orb);
glPushMatrix();
glTranslatef((float) x, (float) y, (float) z);

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<FallingTile> tile = dynamic_pointer_cast<FallingTile>(_tile);
std::shared_ptr<FallingTile> tile = std::dynamic_pointer_cast<FallingTile>(_tile);
glPushMatrix();
glTranslatef((float) x, (float) y, (float) z);

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

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<FishingHook> hook = dynamic_pointer_cast<FishingHook>(_hook);
std::shared_ptr<FishingHook> hook = std::dynamic_pointer_cast<FishingHook>(_hook);
glPushMatrix();
@ -62,7 +62,7 @@ void FishingHookRenderer::render(std::shared_ptr<Entity> _hook, double x, double
double xp = hook->owner->xo + (hook->owner->x - hook->owner->xo) * a + vv->x;
double yp = hook->owner->yo + (hook->owner->y - hook->owner->yo) * a + vv->y;
double zp = hook->owner->zo + (hook->owner->z - hook->owner->zo) * a + vv->z;
double yOffset = hook->owner != dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player) ? hook->owner->getHeadHeight() : 0;
double yOffset = hook->owner != std::dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player) ? hook->owner->getHeadHeight() : 0;
// 4J-PB - changing this to be per player
//if (this->entityRenderDispatcher->options->thirdPersonView)

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)
{
std::shared_ptr<Ghast> ghast = dynamic_pointer_cast<Ghast>(mob);
std::shared_ptr<Ghast> ghast = std::dynamic_pointer_cast<Ghast>(mob);
float ss = (ghast->oCharge+(ghast->charge-ghast->oCharge)*a)/20.0f;
if (ss<0) ss = 0;

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 -
// do some casting around instead
std::shared_ptr<ItemFrame> itemFrame = dynamic_pointer_cast<ItemFrame>(_itemframe);
std::shared_ptr<ItemFrame> itemFrame = std::dynamic_pointer_cast<ItemFrame>(_itemframe);
glPushMatrix();
float xOffs = (float) (itemFrame->x - x) - 0.5f;

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

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

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<ItemEntity> itemEntity = dynamic_pointer_cast<ItemEntity>(_itemEntity);
std::shared_ptr<ItemEntity> itemEntity = std::dynamic_pointer_cast<ItemEntity>(_itemEntity);
random->setSeed(187);
std::shared_ptr<ItemInstance> item = itemEntity->getItem();

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) )
{
int col = PotionBrewing::getColorValue((dynamic_pointer_cast<ThrownPotion>(e) )->getPotionValue(), false);
int col = PotionBrewing::getColorValue((std::dynamic_pointer_cast<ThrownPotion>(e) )->getPotionValue(), false);
float red = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;

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 -
// do some casting around instead
std::shared_ptr<LavaSlime> mob = dynamic_pointer_cast<LavaSlime>(_mob);
std::shared_ptr<LavaSlime> mob = std::dynamic_pointer_cast<LavaSlime>(_mob);
int modelVersion = ((LavaSlimeModel *) model)->getModelVersion();
if (modelVersion != this->modelVersion)
{
@ -27,7 +27,7 @@ void LavaSlimeRenderer::scale(std::shared_ptr<Mob> _slime, float a)
{
// 4J - original version used generics and thus had an input parameter of type LavaSlime rather than std::shared_ptr<Mob> we have here -
// do some casting around instead
std::shared_ptr<LavaSlime> slime = dynamic_pointer_cast<LavaSlime>(_slime);
std::shared_ptr<LavaSlime> slime = std::dynamic_pointer_cast<LavaSlime>(_slime);
int size = slime->getSize();
float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1);
float w = 1 / (ss + 1);

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

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

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
// able to do that so dynamically casting to get the more specific type here.
std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(_mob);
std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(_mob);
glPushMatrix();
glDisable(GL_CULL_FACE);
@ -52,9 +52,9 @@ void MobRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, doubl
float bodyRot = rotlerp(mob->yBodyRotO, mob->yBodyRot, a);
float headRot = rotlerp(mob->yHeadRotO, mob->yHeadRot, a);
if (mob->isRiding() && dynamic_pointer_cast<Mob>(mob->riding))
if (mob->isRiding() && std::dynamic_pointer_cast<Mob>(mob->riding))
{
std::shared_ptr<Mob> riding = dynamic_pointer_cast<Mob>(mob->riding);
std::shared_ptr<Mob> riding = std::dynamic_pointer_cast<Mob>(mob->riding);
bodyRot = rotlerp(riding->yBodyRotO, riding->yBodyRot, a);
float headDiff = Mth::wrapDegrees(headRot - bodyRot);
@ -235,7 +235,7 @@ void MobRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, doubl
void MobRenderer::renderModel(std::shared_ptr<Entity> mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale)
{
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player);
bindTexture(mob->customTextureUrl, mob->getTexture());
if (!mob->isInvisible())
@ -396,7 +396,7 @@ void MobRenderer::renderNameTag(std::shared_ptr<Mob> mob, const std::wstring& Or
Tesselator *t = Tesselator::getInstance();
int offs = 0;
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mob);
if (player != NULL && app.isXuidDeadmau5( player->getXuid() ) ) offs = -10;
std::wstring playerName;

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<MobSpawnerTileEntity> spawner = dynamic_pointer_cast<MobSpawnerTileEntity>(_spawner);
std::shared_ptr<MobSpawnerTileEntity> spawner = std::dynamic_pointer_cast<MobSpawnerTileEntity>(_spawner);
glPushMatrix();
glTranslatef((float) x + 0.5f, (float) y, (float) z + 0.5f);

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 -
// do some casting around instead
//std::shared_ptr<MushroomCow> mob = dynamic_pointer_cast<MushroomCow>(_mob);
//std::shared_ptr<MushroomCow> mob = std::dynamic_pointer_cast<MushroomCow>(_mob);
// 4J Stu - No need to do the cast, just pass through as-is
MobRenderer::render(_mob, x, y, z, rot, a);
@ -23,7 +23,7 @@ void MushroomCowRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a
{
// 4J - original version used generics and thus had an input parameter of type MushroomCow rather than std::shared_ptr<Mob> we have here -
// do some casting around instead
std::shared_ptr<MushroomCow> mob = dynamic_pointer_cast<MushroomCow>(_mob);
std::shared_ptr<MushroomCow> mob = std::dynamic_pointer_cast<MushroomCow>(_mob);
MobRenderer::additionalRendering(mob, a);
if (mob->isBaby()) return;
bindTexture(TN_TERRAIN); // 4J was "/terrain.png"

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 -
// do some casting around instead
std::shared_ptr<Ozelot> mob = dynamic_pointer_cast<Ozelot>(_mob);
std::shared_ptr<Ozelot> mob = std::dynamic_pointer_cast<Ozelot>(_mob);
MobRenderer::scale(mob, a);
if (mob->isTame())
{

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)
{
// 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);

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(_pig);
std::shared_ptr<Pig> pig = std::dynamic_pointer_cast<Pig>(_pig);
MemSect(31);
bindTexture(TN_MOB_SADDLE); // 4J was L"/mob/saddle.png"

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<PistonPieceEntity> entity = dynamic_pointer_cast<PistonPieceEntity>(_entity);
std::shared_ptr<PistonPieceEntity> entity = std::dynamic_pointer_cast<PistonPieceEntity>(_entity);
Tile *tile = Tile::tiles[entity->getId()];
if (tile != NULL && entity->getProgress(a) <= 1) // 4J - changed condition from < to <= as our chunk update is async to main thread and so we can have to render these with progress of 1

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(_player);
// 4J-PB - need to disable rendering armour for some special skins (Daleks)
unsigned int uiAnimOverrideBitmask=player->getAnimOverrideBitmask();
@ -111,7 +111,7 @@ int PlayerRenderer::prepareArmor(std::shared_ptr<Mob> _player, int layer, float
void PlayerRenderer::prepareSecondPassArmor(std::shared_ptr<Mob> _player, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(_player);
std::shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
if (itemInstance != NULL)
{
@ -130,7 +130,7 @@ void PlayerRenderer::prepareSecondPassArmor(std::shared_ptr<Mob> _player, int la
void PlayerRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob);
if(mob->hasInvisiblePrivilege()) return;
@ -169,7 +169,7 @@ void PlayerRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, do
armorParts1->sneaking = armorParts2->sneaking = humanoidModel->sneaking = mob->isSneaking();
double yp = y - mob->heightOffset;
if (mob->isSneaking() && (dynamic_pointer_cast<LocalPlayer>(mob) == NULL))
if (mob->isSneaking() && (std::dynamic_pointer_cast<LocalPlayer>(mob) == NULL))
{
yp -= 2 / 16.0f;
}
@ -231,7 +231,7 @@ void PlayerRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, do
void PlayerRenderer::renderName(std::shared_ptr<Mob> _mob, double x, double y, double z)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob);
if (Minecraft::renderNames() && mob != entityRenderDispatcher->cameraEntity
&& !mob->isInvisibleTo(Minecraft::GetInstance()->player) ) // 4J-JEV: Todo, move to LivingEntityRenderer.
@ -321,7 +321,7 @@ void PlayerRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
MobRenderer::additionalRendering(_mob,a);
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<ItemInstance> headGear = mob->inventory->getArmor(3);
if (headGear != NULL)
@ -543,7 +543,7 @@ void PlayerRenderer::renderHand()
void PlayerRenderer::setupPosition(std::shared_ptr<Mob> _mob, double x, double y, double z)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob);
if (mob->isAlive() && mob->isSleeping())
{
@ -559,7 +559,7 @@ void PlayerRenderer::setupPosition(std::shared_ptr<Mob> _mob, double x, double y
void PlayerRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob);
if (mob->isAlive() && mob->isSleeping())
{
@ -578,7 +578,7 @@ void PlayerRenderer::renderShadow(std::shared_ptr<Entity> e, double x, double y,
{
if(app.GetGameHostOption(eGameHostOption_HostCanBeInvisible) > 0)
{
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e);
if(player != NULL && player->hasInvisiblePrivilege()) return;
}
EntityRenderer::renderShadow(e,x,y,z,pow,a);

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(_sheep);
std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(_sheep);
if (layer == 0 && !sheep->isSheared() &&
!sheep->isInvisibleTo(Minecraft::GetInstance()->player)) // 4J-JEV: Todo, merge with java fix (for invisible sheep armour) in '1.7.5'.

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

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)
{
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());
}

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

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 -
// do some casting around instead
std::shared_ptr<SnowMan> mob = dynamic_pointer_cast<SnowMan>(_mob);
std::shared_ptr<SnowMan> mob = std::dynamic_pointer_cast<SnowMan>(_mob);
MobRenderer::additionalRendering(mob, a);
std::shared_ptr<ItemInstance> headGear = std::shared_ptr<ItemInstance>( new ItemInstance(Tile::pumpkin, 1) );

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

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

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)
{
// 4J Convert as we aren't using a templated class
std::shared_ptr<TheEndPortalTileEntity> table = dynamic_pointer_cast<TheEndPortalTileEntity>(_table);
std::shared_ptr<TheEndPortalTileEntity> table = std::dynamic_pointer_cast<TheEndPortalTileEntity>(_table);
float xx = (float) (tileEntityRenderDispatcher->xPlayer);
float yy = (float) (tileEntityRenderDispatcher->yPlayer);
float zz = (float) (tileEntityRenderDispatcher->zPlayer);

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<PrimedTnt> tnt = dynamic_pointer_cast<PrimedTnt>(_tnt);
std::shared_ptr<PrimedTnt> tnt = std::dynamic_pointer_cast<PrimedTnt>(_tnt);
glPushMatrix();
glTranslatef((float) x, (float) y, (float) z);

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 -
// do some casting around instead
std::shared_ptr<VillagerGolem> mob = dynamic_pointer_cast<VillagerGolem>(_mob);
std::shared_ptr<VillagerGolem> mob = std::dynamic_pointer_cast<VillagerGolem>(_mob);
MobRenderer::setupRotations(mob, bob, bodyRot, a);
if (mob->walkAnimSpeed < 0.01) return;
@ -38,7 +38,7 @@ void VillagerGolemRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float
{
// 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
std::shared_ptr<VillagerGolem> mob = dynamic_pointer_cast<VillagerGolem>(_mob);
std::shared_ptr<VillagerGolem> mob = std::dynamic_pointer_cast<VillagerGolem>(_mob);
MobRenderer::additionalRendering(mob, a);
if (mob->getOfferFlowerTick() == 0) return;

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 -
// do some casting around instead
std::shared_ptr<Villager> mob = dynamic_pointer_cast<Villager>(_mob);
std::shared_ptr<Villager> mob = std::dynamic_pointer_cast<Villager>(_mob);
float s = 15 / 16.0f;
if (mob->getAge() < 0)
{

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)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
std::shared_ptr<Wolf> mob = dynamic_pointer_cast<Wolf>(_mob);
std::shared_ptr<Wolf> mob = std::dynamic_pointer_cast<Wolf>(_mob);
return mob->getTailAngle();
}
@ -20,7 +20,7 @@ int WolfRenderer::prepareArmor(std::shared_ptr<Mob> mob, int layer, float a)
{
if (mob->isInvisibleTo(Minecraft::GetInstance()->player)) return -1; // 4J-JEV: Todo, merge with java fix in '1.7.5'.
std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(mob);
std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(mob);
if (layer == 0 && wolf->isWet())
{
float brightness = wolf->getBrightness(a) * wolf->getWetShade(a);

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

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

@ -276,7 +276,7 @@ void GameRenderer::tick(bool first) // 4J - add bFirst
if (mc->cameraTargetPlayer == NULL)
{
mc->cameraTargetPlayer = dynamic_pointer_cast<Mob>(mc->player);
mc->cameraTargetPlayer = std::dynamic_pointer_cast<Mob>(mc->player);
}
float brr = mc->level->getBrightness(Mth::floor(mc->cameraTargetPlayer->x), Mth::floor(mc->cameraTargetPlayer->y), Mth::floor(mc->cameraTargetPlayer->z));
@ -407,7 +407,7 @@ float GameRenderer::GetFovVal()
void GameRenderer::tickFov()
{
std::shared_ptr<LocalPlayer>player = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
std::shared_ptr<LocalPlayer>player = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
int playerIdx = player ? player->GetXboxPad() : 0;
tFov[playerIdx] = player->getFieldOfViewModifier();
@ -420,7 +420,7 @@ float GameRenderer::getFov(float a, bool applyEffects)
{
if (cameraFlip > 0 ) return 90;
std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
int playerIdx = player ? player->GetXboxPad() : 0;
float fov = m_fov;//70;
if (applyEffects)
@ -470,12 +470,12 @@ void GameRenderer::bobHurt(float a)
void GameRenderer::bobView(float a)
{
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mc->cameraTargetPlayer);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mc->cameraTargetPlayer);
if(player==NULL)
{
return;
}
//std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mc->cameraTargetPlayer);
//std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mc->cameraTargetPlayer);
float wda = player->walkDist - player->walkDistO;
float b = -(player->walkDist + wda * a);
@ -490,7 +490,7 @@ void GameRenderer::bobView(float a)
void GameRenderer::moveCameraToPlayer(float a)
{
std::shared_ptr<Mob> player = mc->cameraTargetPlayer;
std::shared_ptr<LocalPlayer> localplayer = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
std::shared_ptr<LocalPlayer> localplayer = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
float heightOffset = player->heightOffset - 1.62f;
double x = player->xo + (player->x - player->xo) * a;
@ -724,7 +724,7 @@ void GameRenderer::renderItemInHand(float a, int eye)
{
if (cameraFlip > 0) return;
std::shared_ptr<LocalPlayer> localplayer = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
std::shared_ptr<LocalPlayer> localplayer = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
// 4J-PB - to turn off the hand for screenshots, but not when the item held is a map
if ( localplayer!=NULL)
@ -1405,10 +1405,10 @@ void GameRenderer::renderLevel(float a, __int64 until)
PIXEndNamedEvent();
turnOffLightLayer(a); // 4J - brought forward from 1.8.2
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(cameraEntity);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(cameraEntity);
if (mc->hitResult != NULL && cameraEntity->isUnderLiquid(Material::water) && player!=NULL) //&& !mc->options.hideGui)
{
//std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(cameraEntity);
//std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(cameraEntity);
glDisable(GL_ALPHA_TEST);
levelRenderer->renderHit(player, mc->hitResult, 0, player->inventory->getSelected(), a);
levelRenderer->renderHitOutline(player, mc->hitResult, 0, player->inventory->getSelected(), a);
@ -1463,11 +1463,11 @@ void GameRenderer::renderLevel(float a, __int64 until)
glEnable(GL_CULL_FACE);
glDisable(GL_BLEND);
if (zoom == 1 && (dynamic_pointer_cast<Player>(cameraEntity)!=NULL)) //&& !mc->options.hideGui)
if (zoom == 1 && (std::dynamic_pointer_cast<Player>(cameraEntity)!=NULL)) //&& !mc->options.hideGui)
{
if (mc->hitResult != NULL && !cameraEntity->isUnderLiquid(Material::water))
{
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(cameraEntity);
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(cameraEntity);
glDisable(GL_ALPHA_TEST);
levelRenderer->renderHit(player, mc->hitResult, 0, player->inventory->getSelected(), a);
levelRenderer->renderHitOutline(player, mc->hitResult, 0, player->inventory->getSelected(), a);
@ -1484,7 +1484,7 @@ void GameRenderer::renderLevel(float a, __int64 until)
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
levelRenderer->renderDestroyAnimation(Tesselator::getInstance(), dynamic_pointer_cast<Player>(cameraEntity), a);
levelRenderer->renderDestroyAnimation(Tesselator::getInstance(), std::dynamic_pointer_cast<Player>(cameraEntity), a);
glDisable(GL_BLEND);
if (mc->options->isCloudsOn())
@ -1981,9 +1981,9 @@ void GameRenderer::setupFog(int i, float alpha)
// 4J - check for creative mode brought forward from 1.2.3
bool creative = false;
if (dynamic_pointer_cast<Player>(player) )
if (std::dynamic_pointer_cast<Player>(player) )
{
creative = (dynamic_pointer_cast<Player>(player))->abilities.instabuild;
creative = (std::dynamic_pointer_cast<Player>(player))->abilities.instabuild;
}
if (i == 999)

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
//if (entity == mc->cameraTargetPlayer && !mc->options->thirdPersonView && !mc->cameraTargetPlayer->isSleeping()) continue;
std::shared_ptr<LocalPlayer> localplayer = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
std::shared_ptr<LocalPlayer> localplayer = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer);
if (localplayer && entity == mc->cameraTargetPlayer && !localplayer->ThirdPersonView() && !mc->cameraTargetPlayer->isSleeping()) continue;
@ -2802,7 +2802,7 @@ std::shared_ptr<Particle> LevelRenderer::addParticleInternal(ePARTICLE_TYPE ePar
break;
case eParticleType_instantSpell:
particle = std::shared_ptr<Particle>(new SpellParticle(lev, x, y, z, xa, ya, za));
dynamic_pointer_cast<SpellParticle>(particle)->setBaseTex(9 * 16);
std::dynamic_pointer_cast<SpellParticle>(particle)->setBaseTex(9 * 16);
break;
case eParticleType_note:
particle = std::shared_ptr<Particle>( new NoteParticle(lev, x, y, z, xa, ya, za) );
@ -2877,7 +2877,7 @@ std::shared_ptr<Particle> LevelRenderer::addParticleInternal(ePARTICLE_TYPE ePar
else if( ( eParticleType >= eParticleType_tilecrack_base ) && ( eParticleType <= eParticleType_tilecrack_last ) )
{
int id = PARTICLE_CRACK_ID(eParticleType), data = PARTICLE_CRACK_DATA(eParticleType);
particle = dynamic_pointer_cast<Particle>( std::shared_ptr<TerrainParticle>(new TerrainParticle(lev, x, y, z, xa, ya, za, Tile::tiles[id], 0, data, textures))->init(data) );
particle = std::dynamic_pointer_cast<Particle>( std::shared_ptr<TerrainParticle>(new TerrainParticle(lev, x, y, z, xa, ya, za, Tile::tiles[id], 0, data, textures))->init(data) );
}
}

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)
{
glPushMatrix();
std::shared_ptr<EnderDragon> dragon = dynamic_pointer_cast<EnderDragon>(entity);
std::shared_ptr<EnderDragon> dragon = std::dynamic_pointer_cast<EnderDragon>(entity);
float ttt = dragon->oFlapTime + (dragon->flapTime - dragon->oFlapTime) * a;
jaw->xRot = (float) (Mth::sin(ttt * PI * 2) + 1) * 0.2f;

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)
{
std::shared_ptr<LavaSlime> lavaSlime = dynamic_pointer_cast<LavaSlime>(mob);
std::shared_ptr<LavaSlime> lavaSlime = std::dynamic_pointer_cast<LavaSlime>(mob);
float slimeSquish = (lavaSlime->oSquish + (lavaSlime->squish - lavaSlime->oSquish) * a);
if (slimeSquish < 0)

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)
{
std::shared_ptr<Ozelot> ozelot = dynamic_pointer_cast<Ozelot>(mob);
std::shared_ptr<Ozelot> ozelot = std::dynamic_pointer_cast<Ozelot>(mob);
body->y = bodyWalkY;
body->z = bodyWalkZ;

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);
std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(mob);
std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(mob);
head->y = 6 + sheep->getHeadEatPositionScale(a) * 9.0f;
headXRot = sheep->getHeadEatAngleScale(a);
}

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);
std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(mob);
std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(mob);
head->y = 6 + sheep->getHeadEatPositionScale(a) * 9.0f;
headXRot = sheep->getHeadEatAngleScale(a);
}

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)
{
std::shared_ptr<VillagerGolem> vg = dynamic_pointer_cast<VillagerGolem>(mob);
std::shared_ptr<VillagerGolem> vg = std::dynamic_pointer_cast<VillagerGolem>(mob);
int attackTick = vg->getAttackAnimationTick();
if (attackTick > 0)
{

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)
{
std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(mob);
std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(mob);
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;
yd = (yd - 0.1f) * power + 0.1f;
zd *= power;
return dynamic_pointer_cast<Particle>( shared_from_this() );
return std::dynamic_pointer_cast<Particle>( shared_from_this() );
}
std::shared_ptr<Particle> Particle::scale(float scale)
{
setSize(0.2f * scale, 0.2f * scale);
size *= scale;
return dynamic_pointer_cast<Particle>( shared_from_this() );
return std::dynamic_pointer_cast<Particle>( shared_from_this() );
}
void Particle::setColor(float r, float g, float b)

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
{
if (tile == Tile::grass) return dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
if (tile == Tile::grass) return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
int col = tile->getColor(level, x, y, z, data); // 4J - added data parameter
rCol *= ((col >> 16) & 0xff) / 255.0f;
gCol *= ((col >> 8) & 0xff) / 255.0f;
bCol *= ((col) & 0xff) / 255.0f;
return dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
}
std::shared_ptr<TerrainParticle> TerrainParticle::init(int data)
{
if (tile == Tile::grass) return dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
if (tile == Tile::grass) return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
int col = tile->getColor(data);
rCol *= ((col >> 16) & 0xff) / 255.0f;
gCol *= ((col >> 8) & 0xff) / 255.0f;
bCol *= ((col) & 0xff) / 255.0f;
return dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() );
}
int TerrainParticle::getParticleTexture()

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()
{
AbstractContainerScreen::removed();
menu->removed(dynamic_pointer_cast<Player>(minecraft->player));
menu->removed(std::dynamic_pointer_cast<Player>(minecraft->player));
}
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)
{
this->wantedX = target->x;
std::shared_ptr<Mob> targetMob = dynamic_pointer_cast<Mob>(target);
std::shared_ptr<Mob> targetMob = std::dynamic_pointer_cast<Mob>(target);
if (targetMob != NULL) this->wantedY = target->y + targetMob->getHeadHeight();
else this->wantedY = (target->bb->y0 + target->bb->y1) / 2;
this->wantedZ = target->z;

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

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

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

@ -33,7 +33,7 @@ bool AvoidPlayerGoal::canUse()
{
if (avoidType == typeid(Player))
{
std::shared_ptr<TamableAnimal> tamableAnimal = dynamic_pointer_cast<TamableAnimal>(mob->shared_from_this());
std::shared_ptr<TamableAnimal> tamableAnimal = std::dynamic_pointer_cast<TamableAnimal>(mob->shared_from_this());
if (tamableAnimal != NULL && tamableAnimal->isTame()) return false;
toAvoid = std::weak_ptr<Entity>(mob->level->getNearestPlayer(mob->shared_from_this(), maxDist));
if (toAvoid.lock() == NULL) return false;
@ -52,7 +52,7 @@ bool AvoidPlayerGoal::canUse()
if (!mob->getSensing()->canSee(toAvoid.lock())) return false;
Vec3 *pos = RandomPos::getPosAvoid(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(toAvoid.lock()->x, toAvoid.lock()->y, toAvoid.lock()->z));
Vec3 *pos = RandomPos::getPosAvoid(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(toAvoid.lock()->x, toAvoid.lock()->y, toAvoid.lock()->z));
if (pos == NULL) return false;
if (toAvoid.lock()->distanceToSqr(pos->x, pos->y, pos->z) < toAvoid.lock()->distanceToSqr(mob->shared_from_this())) return false;
delete path;

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));
for(AUTO_VAR(it, others->begin()); it != others->end(); ++it)
{
std::shared_ptr<Animal> p = dynamic_pointer_cast<Animal>(*it);
std::shared_ptr<Animal> p = std::dynamic_pointer_cast<Animal>(*it);
if (animal->canMate(p))
{
delete others;

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

@ -36,13 +36,13 @@ void ControlledByPlayerGoal::stop()
bool ControlledByPlayerGoal::canUse()
{
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( mob->rider.lock() );
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( mob->rider.lock() );
return mob->isAlive() && player && (boosting || mob->canBeControlledByRider());
}
void ControlledByPlayerGoal::tick()
{
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob->rider.lock());
std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mob->rider.lock());
PathfinderMob *pig = (PathfinderMob *)mob;
float yrd = Mth::wrapDegrees(player->yRot - mob->yRot) * 0.5f;

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

@ -13,7 +13,7 @@ bool DefendVillageTargetGoal::canUse()
{
std::shared_ptr<Village> village = golem->getVillage();
if (village == NULL) return false;
potentialTarget = std::weak_ptr<Mob>(village->getClosestAggressor(dynamic_pointer_cast<Mob>(golem->shared_from_this())));
potentialTarget = std::weak_ptr<Mob>(village->getClosestAggressor(std::dynamic_pointer_cast<Mob>(golem->shared_from_this())));
return canAttack(potentialTarget.lock(), false);
}

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

@ -24,7 +24,7 @@ bool FollowParentGoal::canUse()
double closestDistSqr = Double::MAX_VALUE;
for(AUTO_VAR(it, parents->begin()); it != parents->end(); ++it)
{
std::shared_ptr<Animal> parent = dynamic_pointer_cast<Animal>(*it);
std::shared_ptr<Animal> parent = std::dynamic_pointer_cast<Animal>(*it);
if (parent->getAge() < 0) continue;
double distSqr = animal->distanceToSqr(parent);
if (distSqr > closestDistSqr) continue;

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));
for(AUTO_VAR(it, nearby->begin()); it != nearby->end(); ++it)
{
std::shared_ptr<Mob> other = dynamic_pointer_cast<Mob>(*it);
std::shared_ptr<Mob> other = std::dynamic_pointer_cast<Mob>(*it);
if (this->mob->shared_from_this() == other) continue;
if (other->getTarget() != NULL) continue;
other->setTarget(mob->getLastHurtByMob());

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

@ -12,7 +12,7 @@ bool LookAtTradingPlayerGoal::canUse()
{
if (villager->isTrading())
{
lookAt = std::weak_ptr<Entity>(dynamic_pointer_cast<Entity>(villager->getTradingPlayer()));
lookAt = std::weak_ptr<Entity>(std::dynamic_pointer_cast<Entity>(villager->getTradingPlayer()));
return true;
}
return false;

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());
if (mate == NULL) return false;
partner = std::weak_ptr<Villager>(dynamic_pointer_cast<Villager>(mate));
partner = std::weak_ptr<Villager>(std::dynamic_pointer_cast<Villager>(mate));
if (partner.lock()->getAge() != 0) return false;
return true;

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)
{
Vec3 *pos = RandomPos::getPosTowards(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 14, 3, Vec3::newTemp(_doorInfo->getIndoorX() + 0.5, _doorInfo->getIndoorY(), _doorInfo->getIndoorZ() + 0.5));
Vec3 *pos = RandomPos::getPosTowards(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 14, 3, Vec3::newTemp(_doorInfo->getIndoorX() + 0.5, _doorInfo->getIndoorY(), _doorInfo->getIndoorZ() + 0.5));
if (pos != NULL) mob->getNavigation()->moveTo(pos->x, pos->y, pos->z, 0.3f);
}
else mob->getNavigation()->moveTo(_doorInfo->getIndoorX() + 0.5, _doorInfo->getIndoorY(), _doorInfo->getIndoorZ() + 0.5, 0.3f);

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

@ -46,7 +46,7 @@ bool MoveThroughVillageGoal::canUse()
mob->getNavigation()->setCanOpenDoors(oldCanOpenDoors);
if (path != NULL) return true;
Vec3 *pos = RandomPos::getPosTowards(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7, Vec3::newTemp(_doorInfo->x, _doorInfo->y, _doorInfo->z));
Vec3 *pos = RandomPos::getPosTowards(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7, Vec3::newTemp(_doorInfo->x, _doorInfo->y, _doorInfo->z));
if (pos == NULL) return false;
mob->getNavigation()->setCanOpenDoors(false);
delete path;

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

@ -19,7 +19,7 @@ bool MoveTowardsRestrictionGoal::canUse()
{
if (mob->isWithinRestriction()) return false;
Pos *towards = mob->getRestrictCenter();
Vec3 *pos = RandomPos::getPosTowards(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(towards->x, towards->y, towards->z));
Vec3 *pos = RandomPos::getPosTowards(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(towards->x, towards->y, towards->z));
if (pos == NULL) return false;
wantedX = pos->x;
wantedY = pos->y;

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

@ -19,7 +19,7 @@ bool MoveTowardsTargetGoal::canUse()
target = std::weak_ptr<Mob>(mob->getTarget());
if (target.lock() == NULL) return false;
if (target.lock()->distanceToSqr(mob->shared_from_this()) > within * within) return false;
Vec3 *pos = RandomPos::getPosTowards(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(target.lock()->x, target.lock()->y, target.lock()->z));
Vec3 *pos = RandomPos::getPosTowards(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(target.lock()->x, target.lock()->y, target.lock()->z));
if (pos == NULL) return false;
wantedX = pos->x;
wantedY = pos->y;

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

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

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)
{
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)
{

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

@ -16,7 +16,7 @@ bool OfferFlowerGoal::canUse()
{
if (!golem->level->isDay()) return false;
if (golem->getRandom()->nextInt(8000) != 0) return false;
villager = std::weak_ptr<Villager>(dynamic_pointer_cast<Villager>( golem->level->getClosestEntityOfClass(typeid(Villager), golem->bb->grow(6, 2, 6), golem->shared_from_this()) ));
villager = std::weak_ptr<Villager>(std::dynamic_pointer_cast<Villager>( golem->level->getClosestEntityOfClass(typeid(Villager), golem->bb->grow(6, 2, 6), golem->shared_from_this()) ));
return villager.lock() != NULL;
}

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

@ -16,7 +16,7 @@ PanicGoal::PanicGoal(PathfinderMob *mob, float speed)
bool PanicGoal::canUse()
{
if (mob->getLastHurtByMob() == NULL) return false;
Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 5, 4);
Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 5, 4);
if (pos == NULL) return false;
posX = pos->x;
posY = pos->y;

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

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

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