+1 -1

Minecraft.Client/ArrowRenderer.cpp

··· 7 7 { 8 8 // 4J - original version used generics and thus had an input parameter of type Arrow rather than std::shared_ptr<Entity> we have here - 9 9 // do some casting around instead 10 10 - std::shared_ptr<Arrow> arrow = std::dynamic_pointer_cast<Arrow>(_arrow); 10 10 + std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(_arrow); 11 11 bindTexture(TN_ITEM_ARROWS); // 4J - was L"/item/arrows.png" 12 12 13 13 glPushMatrix();

+1 -1

Minecraft.Client/BlazeRenderer.cpp

··· 12 12 { 13 13 // 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity> we have here - 14 14 // do some casting around instead 15 15 - std::shared_ptr<Blaze> mob = std::dynamic_pointer_cast<Blaze>(_mob); 15 15 + std::shared_ptr<Blaze> mob = dynamic_pointer_cast<Blaze>(_mob); 16 16 17 17 int modelVersion = ((BlazeModel *) model)->modelVersion(); 18 18 if (modelVersion != this->modelVersion)

+1 -1

Minecraft.Client/BoatRenderer.cpp

··· 14 14 { 15 15 // 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity> we have here - 16 16 // do some casting around instead 17 17 - std::shared_ptr<Boat> boat = std::dynamic_pointer_cast<Boat>(_boat); 17 17 + std::shared_ptr<Boat> boat = dynamic_pointer_cast<Boat>(_boat); 18 18 19 19 glPushMatrix(); 20 20

+1 -1

Minecraft.Client/ChestRenderer.cpp

··· 21 21 void ChestRenderer::render(std::shared_ptr<TileEntity> _chest, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled) 22 22 { 23 23 // 4J Convert as we aren't using a templated class 24 24 - std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(_chest); 24 24 + std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(_chest); 25 25 26 26 int data; 27 27

+1 -1

Minecraft.Client/ChickenRenderer.cpp

··· 15 15 float ChickenRenderer::getBob(std::shared_ptr<Mob> _mob, float a) 16 16 { 17 17 // 4J - dynamic cast required because we aren't using templates/generics in our version 18 18 - std::shared_ptr<Chicken> mob = std::dynamic_pointer_cast<Chicken>(_mob); 18 18 + std::shared_ptr<Chicken> mob = dynamic_pointer_cast<Chicken>(_mob); 19 19 20 20 float flap = mob->oFlap+(mob->flap-mob->oFlap)*a; 21 21 float flapSpeed = mob->oFlapSpeed+(mob->flapSpeed-mob->oFlapSpeed)*a;

+27 -27

Minecraft.Client/ClientConnection.cpp

··· 446 446 } 447 447 } 448 448 } 449 449 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(owner); 449 449 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(owner); 450 450 if (player != NULL) 451 451 { 452 452 std::shared_ptr<FishingHook> hook = std::shared_ptr<FishingHook>( new FishingHook(level, x, y, z, player) ); ··· 547 547 } 548 548 } 549 549 } 550 550 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(owner); 550 550 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(owner); 551 551 if (player != NULL) 552 552 { 553 553 std::shared_ptr<FishingHook> hook = std::shared_ptr<FishingHook>( new FishingHook(level, x, y, z, player) ); ··· 653 653 } 654 654 } 655 655 656 656 - if (std::dynamic_pointer_cast<Mob>(owner) != NULL) 656 656 + if (dynamic_pointer_cast<Mob>(owner) != NULL) 657 657 { 658 658 - std::dynamic_pointer_cast<Arrow>(e)->owner = std::dynamic_pointer_cast<Mob>(owner); 658 658 + dynamic_pointer_cast<Arrow>(e)->owner = dynamic_pointer_cast<Mob>(owner); 659 659 } 660 660 } 661 661 ··· 1207 1207 void ClientConnection::handleTakeItemEntity(std::shared_ptr<TakeItemEntityPacket> packet) 1208 1208 { 1209 1209 std::shared_ptr<Entity> from = getEntity(packet->itemId); 1210 1210 - std::shared_ptr<Mob> to = std::dynamic_pointer_cast<Mob>(getEntity(packet->playerId)); 1210 1210 + std::shared_ptr<Mob> to = dynamic_pointer_cast<Mob>(getEntity(packet->playerId)); 1211 1211 1212 1212 // 4J - the original game could assume that if getEntity didn't find the player, it must be the local player. We 1213 1213 // need to search all local players ··· 1240 1240 // "from" reference if we've already removed the item for an earlier processed connection 1241 1241 if( isLocalPlayer ) 1242 1242 { 1243 1243 - std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>(to); 1243 1243 + std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>(to); 1244 1244 1245 1245 // 4J Stu - Fix for #10213 - UI: Local clients cannot progress through the tutorial normally. 1246 1246 // We only send this packet once if many local players can see the event, so make sure we update ··· 1571 1571 if (e == NULL) return; 1572 1572 if (packet->action == AnimatePacket::SWING) 1573 1573 { 1574 1574 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e); 1574 1574 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e); 1575 1575 if(player != NULL) player->swing(); 1576 1576 } 1577 1577 else if (packet->action == AnimatePacket::HURT) ··· 1580 1580 } 1581 1581 else if (packet->action == AnimatePacket::WAKE_UP) 1582 1582 { 1583 1583 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e); 1583 1583 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e); 1584 1584 if(player != NULL) player->stopSleepInBed(false, false, false); 1585 1585 } 1586 1586 else if (packet->action == AnimatePacket::RESPAWN) ··· 1598 1598 critParticle->CritParticlePostConstructor(); 1599 1599 minecraft->particleEngine->add(critParticle); 1600 1600 } 1601 1601 - else if (packet->action == AnimatePacket::EAT && std::dynamic_pointer_cast<RemotePlayer>(e) != NULL) 1601 1601 + else if (packet->action == AnimatePacket::EAT && dynamic_pointer_cast<RemotePlayer>(e) != NULL) 1602 1602 { 1603 1603 } 1604 1604 ··· 1610 1610 if (e == NULL) return; 1611 1611 if (packet->action == EntityActionAtPositionPacket::START_SLEEP) 1612 1612 { 1613 1613 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e); 1613 1613 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e); 1614 1614 player->startSleepInBed(packet->x, packet->y, packet->z); 1615 1615 1616 1616 if( player == minecraft->localplayers[m_userIndex] ) ··· 2113 2113 float yRot = packet->yRot * 360 / 256.0f; 2114 2114 float xRot = packet->xRot * 360 / 256.0f; 2115 2115 2116 2116 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(EntityIO::newById(packet->type, level)); 2116 2116 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(EntityIO::newById(packet->type, level)); 2117 2117 mob->xp = packet->x; 2118 2118 mob->yp = packet->y; 2119 2119 mob->zp = packet->z; ··· 2153 2153 // 4J Stu - Slimes have a different BB depending on their size which is set in the entity data, so update the BB 2154 2154 if(mob->GetType() == eTYPE_SLIME || mob->GetType() == eTYPE_LAVASLIME) 2155 2155 { 2156 2156 - std::shared_ptr<Slime> slime = std::dynamic_pointer_cast<Slime>(mob); 2156 2156 + std::shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(mob); 2157 2157 slime->setSize( slime->getSize() ); 2158 2158 } 2159 2159 } ··· 2176 2176 std::shared_ptr<Entity> rider = getEntity(packet->riderId); 2177 2177 std::shared_ptr<Entity> ridden = getEntity(packet->riddenId); 2178 2178 2179 2179 - std::shared_ptr<Boat> boat = std::dynamic_pointer_cast<Boat>(ridden); 2179 2179 + std::shared_ptr<Boat> boat = dynamic_pointer_cast<Boat>(ridden); 2180 2180 //if (packet->riderId == minecraft->player->entityId) rider = minecraft->player; 2181 2181 if (packet->riderId == minecraft->localplayers[m_userIndex]->entityId) 2182 2182 { ··· 2327 2327 { 2328 2328 std::shared_ptr<Entity> e = getEntity(packet->id); 2329 2329 if (e == NULL) return; 2330 2330 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e); 2330 2330 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e); 2331 2331 if( e == NULL) return; 2332 2332 2333 2333 bool isLocalPlayer = false; ··· 2382 2382 { 2383 2383 std::shared_ptr<Entity> e = getEntity(packet->id); 2384 2384 if (e == NULL) return; 2385 2385 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e); 2385 2385 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e); 2386 2386 if( e == NULL) return; 2387 2387 2388 2388 bool isLocalPlayer = false; ··· 2765 2765 std::shared_ptr<TileEntity> te = minecraft->level->getTileEntity(packet->x, packet->y, packet->z); 2766 2766 2767 2767 // 4J-PB - on a client connecting, the line below fails 2768 2768 - if (std::dynamic_pointer_cast<SignTileEntity>(te) != NULL) 2768 2768 + if (dynamic_pointer_cast<SignTileEntity>(te) != NULL) 2769 2769 { 2770 2770 - std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>(te); 2770 2770 + std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>(te); 2771 2771 for (int i = 0; i < MAX_SIGN_LINES; i++) 2772 2772 { 2773 2773 ste->SetMessage(i,packet->lines[i]); ··· 2781 2781 } 2782 2782 else 2783 2783 { 2784 2784 - app.DebugPrintf("std::dynamic_pointer_cast<SignTileEntity>(te) == NULL\n"); 2784 2784 + app.DebugPrintf("dynamic_pointer_cast<SignTileEntity>(te) == NULL\n"); 2785 2785 } 2786 2786 } 2787 2787 else ··· 2798 2798 2799 2799 if (te != NULL) 2800 2800 { 2801 2801 - if (packet->type == TileEntityDataPacket::TYPE_MOB_SPAWNER && std::dynamic_pointer_cast<MobSpawnerTileEntity>(te) != NULL) 2801 2801 + if (packet->type == TileEntityDataPacket::TYPE_MOB_SPAWNER && dynamic_pointer_cast<MobSpawnerTileEntity>(te) != NULL) 2802 2802 { 2803 2803 - std::dynamic_pointer_cast<MobSpawnerTileEntity>(te)->load(packet->tag); 2803 2803 + dynamic_pointer_cast<MobSpawnerTileEntity>(te)->load(packet->tag); 2804 2804 } 2805 2805 //else if (packet.type == TileEntityDataPacket.TYPE_ADV_COMMAND && (te instanceof CommandBlockEntity)) 2806 2806 //{ ··· 2810 2810 //{ 2811 2811 // ((BeaconTileEntity) te).load(packet.tag); 2812 2812 //} 2813 2813 - else if (packet->type == TileEntityDataPacket::TYPE_SKULL && std::dynamic_pointer_cast<SkullTileEntity>(te) != NULL) 2813 2813 + else if (packet->type == TileEntityDataPacket::TYPE_SKULL && dynamic_pointer_cast<SkullTileEntity>(te) != NULL) 2814 2814 { 2815 2815 - std::dynamic_pointer_cast<SkullTileEntity>(te)->load(packet->tag); 2815 2815 + dynamic_pointer_cast<SkullTileEntity>(te)->load(packet->tag); 2816 2816 } 2817 2817 } 2818 2818 } ··· 2971 2971 void ClientConnection::handleUpdateMobEffect(std::shared_ptr<UpdateMobEffectPacket> packet) 2972 2972 { 2973 2973 std::shared_ptr<Entity> e = getEntity(packet->entityId); 2974 2974 - if (e == NULL || std::dynamic_pointer_cast<Mob>(e) == NULL) return; 2974 2974 + if (e == NULL || dynamic_pointer_cast<Mob>(e) == NULL) return; 2975 2975 2976 2976 - ( std::dynamic_pointer_cast<Mob>(e) )->addEffect(new MobEffectInstance(packet->effectId, packet->effectDurationTicks, packet->effectAmplifier)); 2976 2976 + ( dynamic_pointer_cast<Mob>(e) )->addEffect(new MobEffectInstance(packet->effectId, packet->effectDurationTicks, packet->effectAmplifier)); 2977 2977 } 2978 2978 2979 2979 void ClientConnection::handleRemoveMobEffect(std::shared_ptr<RemoveMobEffectPacket> packet) 2980 2980 { 2981 2981 std::shared_ptr<Entity> e = getEntity(packet->entityId); 2982 2982 - if (e == NULL || std::dynamic_pointer_cast<Mob>(e) == NULL) return; 2982 2982 + if (e == NULL || dynamic_pointer_cast<Mob>(e) == NULL) return; 2983 2983 2984 2984 - ( std::dynamic_pointer_cast<Mob>(e) )->removeEffectNoUpdate(packet->effectId); 2984 2984 + ( dynamic_pointer_cast<Mob>(e) )->removeEffectNoUpdate(packet->effectId); 2985 2985 } 2986 2986 2987 2987 bool ClientConnection::isServerPacketListener() ··· 3008 3008 std::shared_ptr<Entity> entity = getEntity(packet->m_entityId); 3009 3009 if(entity != NULL && entity->GetType() == eTYPE_PLAYER) 3010 3010 { 3011 3011 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(entity); 3011 3011 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(entity); 3012 3012 player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_All, packet->m_playerPrivileges); 3013 3013 } 3014 3014 if(networkPlayer != NULL && networkPlayer->IsLocal())

+2 -2

Minecraft.Client/Common/GameRules/AddItemRuleDefinition.cpp

··· 118 118 container->setItem( slotId, newItem ); 119 119 added = true; 120 120 } 121 121 - else if(std::dynamic_pointer_cast<Inventory>(container) != NULL) 121 121 + else if(dynamic_pointer_cast<Inventory>(container) != NULL) 122 122 { 123 123 - added = std::dynamic_pointer_cast<Inventory>(container)->add(newItem); 123 123 + added = dynamic_pointer_cast<Inventory>(container)->add(newItem); 124 124 } 125 125 } 126 126 return added;

+2 -2

Minecraft.Client/Common/GameRules/ConsoleSchematicFile.cpp

··· 499 499 500 500 if( e->GetType() == eTYPE_PAINTING ) 501 501 { 502 502 - std::shared_ptr<Painting> painting = std::dynamic_pointer_cast<Painting>(e); 502 502 + std::shared_ptr<Painting> painting = dynamic_pointer_cast<Painting>(e); 503 503 504 504 double tileX = painting->xTile; 505 505 double tileZ = painting->zTile; ··· 512 512 } 513 513 else if( e->GetType() == eTYPE_ITEM_FRAME ) 514 514 { 515 515 - std::shared_ptr<ItemFrame> frame = std::dynamic_pointer_cast<ItemFrame>(e); 515 515 + std::shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame>(e); 516 516 517 517 double tileX = frame->xTile; 518 518 double tileZ = frame->zTile;

+1 -1

Minecraft.Client/Common/GameRules/XboxStructureActionPlaceContainer.cpp

··· 78 78 } 79 79 80 80 level->setTile( worldX, worldY, worldZ, m_tile ); 81 81 - std::shared_ptr<Container> container = std::dynamic_pointer_cast<Container>(level->getTileEntity( worldX, worldY, worldZ )); 81 81 + std::shared_ptr<Container> container = dynamic_pointer_cast<Container>(level->getTileEntity( worldX, worldY, worldZ )); 82 82 83 83 app.DebugPrintf("XboxStructureActionPlaceContainer - placing a container at (%d,%d,%d)\n", worldX, worldY, worldZ); 84 84 if ( container != NULL )

+1 -1

Minecraft.Client/Common/GameRules/XboxStructureActionPlaceSpawner.cpp

··· 54 54 } 55 55 56 56 level->setTile( worldX, worldY, worldZ, m_tile ); 57 57 - std::shared_ptr<MobSpawnerTileEntity> entity = std::dynamic_pointer_cast<MobSpawnerTileEntity>(level->getTileEntity( worldX, worldY, worldZ )); 57 57 + std::shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>(level->getTileEntity( worldX, worldY, worldZ )); 58 58 59 59 #ifndef _CONTENT_PACKAGE 60 60 wprintf(L"XboxStructureActionPlaceSpawner - placing a %ls spawner at (%d,%d,%d)\n", m_entityId.c_str(), worldX, worldY, worldZ);

+1 -1

Minecraft.Client/Common/Tutorial/DiggerItemHint.cpp

··· 62 62 if(itemFound) 63 63 { 64 64 // It's also possible that we could hit TileEntities (eg falling sand) so don't want to give this hint then 65 65 - if( std::dynamic_pointer_cast<Mob>( entity ) != NULL ) 65 65 + if( dynamic_pointer_cast<Mob>( entity ) != NULL ) 66 66 { 67 67 return IDS_TUTORIAL_HINT_ATTACK_WITH_TOOL; 68 68 }

+1 -1

Minecraft.Client/Common/UI/IUIScene_AnvilMenu.cpp

··· 216 216 wchar_t temp[256]; 217 217 swprintf(temp, 256, costString, m_repairMenu->cost); 218 218 m_costString = temp; 219 219 - if(!m_repairMenu->getSlot(RepairMenu::RESULT_SLOT)->mayPickup(std::dynamic_pointer_cast<Player>(m_inventory->player->shared_from_this()))) 219 219 + if(!m_repairMenu->getSlot(RepairMenu::RESULT_SLOT)->mayPickup(dynamic_pointer_cast<Player>(m_inventory->player->shared_from_this()))) 220 220 { 221 221 canAfford = false; 222 222 }

+1 -1

Minecraft.Client/Common/UI/IUIScene_CraftingMenu.cpp

··· 258 258 259 259 if(pRecipeIngredientsRequired[iRecipe].bCanMake[iPad]) 260 260 { 261 261 - pTempItemInst->onCraftedBy(m_pPlayer->level, std::dynamic_pointer_cast<Player>( m_pPlayer->shared_from_this() ), pTempItemInst->count ); 261 261 + pTempItemInst->onCraftedBy(m_pPlayer->level, dynamic_pointer_cast<Player>( m_pPlayer->shared_from_this() ), pTempItemInst->count ); 262 262 // TODO 4J Stu - handleCraftItem should do a lot more than what it does, loads of the "can we craft" code should also probably be 263 263 // shifted to the GameMode 264 264 pMinecraft->localgameModes[iPad]->handleCraftItem(iRecipe,m_pPlayer);

+1 -1

Minecraft.Client/Common/UI/IUIScene_EnchantingMenu.cpp

··· 140 140 break; 141 141 }; 142 142 Minecraft *pMinecraft = Minecraft::GetInstance(); 143 143 - if (index >= 0 && m_menu->clickMenuButton(std::dynamic_pointer_cast<Player>(pMinecraft->localplayers[iPad]), index)) 143 143 + if (index >= 0 && m_menu->clickMenuButton(dynamic_pointer_cast<Player>(pMinecraft->localplayers[iPad]), index)) 144 144 { 145 145 pMinecraft->localgameModes[iPad]->handleInventoryButtonClick(m_menu->containerId, index); 146 146 }

+2 -2

Minecraft.Client/Common/UI/UIScene_AnvilMenu.cpp

··· 56 56 wchar_t temp[256]; 57 57 swprintf(temp, 256, costString, m_repairMenu->cost); 58 58 m_costString = temp; 59 59 - if(!m_repairMenu->getSlot(RepairMenu::RESULT_SLOT)->mayPickup(std::dynamic_pointer_cast<Player>(m_inventory->player->shared_from_this()))) 59 59 + if(!m_repairMenu->getSlot(RepairMenu::RESULT_SLOT)->mayPickup(dynamic_pointer_cast<Player>(m_inventory->player->shared_from_this()))) 60 60 { 61 61 expensive = true; 62 62 } ··· 395 395 // another player destroyed the anvil, so shut down the keyboard if it is displayed 396 396 #if ( defined __PS3__ || defined __ORBIS__ || defined _DURANGO) 397 397 InputManager.DestroyKeyboard(); 398 398 - #endif 398 398 + #endif 399 399 UIScene_AbstractContainerMenu::handleDestroy(); 400 400 }

+2 -2

Minecraft.Client/Common/UI/UIScene_DebugOverlay.cpp

··· 169 169 int id = childId; 170 170 //app.SetXuiServerAction(m_iPad, eXuiServerAction_DropItem, (void *)m_itemIds[id]); 171 171 ClientConnection *conn = Minecraft::GetInstance()->getConnection(ProfileManager.GetPrimaryPad()); 172 172 - conn->send( GiveItemCommand::preparePacket(std::dynamic_pointer_cast<Player>(Minecraft::GetInstance()->localplayers[ProfileManager.GetPrimaryPad()]), m_itemIds[id]) ); 172 172 + conn->send( GiveItemCommand::preparePacket(dynamic_pointer_cast<Player>(Minecraft::GetInstance()->localplayers[ProfileManager.GetPrimaryPad()]), m_itemIds[id]) ); 173 173 } 174 174 break; 175 175 case eControl_Mobs: ··· 185 185 { 186 186 int id = childId; 187 187 ClientConnection *conn = Minecraft::GetInstance()->getConnection(ProfileManager.GetPrimaryPad()); 188 188 - conn->send( EnchantItemCommand::preparePacket(std::dynamic_pointer_cast<Player>(Minecraft::GetInstance()->localplayers[ProfileManager.GetPrimaryPad()]), m_enchantmentIdAndLevels[id].first, m_enchantmentIdAndLevels[id].second) ); 188 188 + conn->send( EnchantItemCommand::preparePacket(dynamic_pointer_cast<Player>(Minecraft::GetInstance()->localplayers[ProfileManager.GetPrimaryPad()]), m_enchantmentIdAndLevels[id].first, m_enchantmentIdAndLevels[id].second) ); 189 189 } 190 190 break; 191 191 case eControl_Schematic:

+7 -7

Minecraft.Client/Common/XUI/XUI_Ctrl_SlotItemCtrlBase.cpp

··· 49 49 } 50 50 else if(pUserDataContainer->m_iPad >= 0 && pUserDataContainer->m_iPad < XUSER_MAX_COUNT) 51 51 { 52 52 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pUserDataContainer->m_iPad] ); 52 52 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pUserDataContainer->m_iPad] ); 53 53 if(player != NULL) item = player->inventory->getCarried(); 54 54 } 55 55 ··· 119 119 } 120 120 else if(pUserDataContainer->m_iPad >= 0 && pUserDataContainer->m_iPad < XUSER_MAX_COUNT) 121 121 { 122 122 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pUserDataContainer->m_iPad] ); 122 122 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pUserDataContainer->m_iPad] ); 123 123 if(player != NULL) return player->inventory->getCarried() == NULL; 124 124 125 125 } ··· 167 167 } 168 168 else if(pUserDataContainer->m_iPad >= 0 && pUserDataContainer->m_iPad < XUSER_MAX_COUNT) 169 169 { 170 170 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pUserDataContainer->m_iPad] ); 170 170 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pUserDataContainer->m_iPad] ); 171 171 if(player != NULL) 172 172 { 173 173 std::shared_ptr<ItemInstance> item = player->inventory->getCarried(); ··· 190 190 } 191 191 else if(pUserDataContainer->m_iPad >= 0 && pUserDataContainer->m_iPad < XUSER_MAX_COUNT) 192 192 { 193 193 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pUserDataContainer->m_iPad] ); 193 193 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pUserDataContainer->m_iPad] ); 194 194 if(player != NULL) return player->inventory->getCarried(); 195 195 196 196 } ··· 268 268 } 269 269 else if(pUserDataContainer->m_iPad >= 0 && pUserDataContainer->m_iPad < XUSER_MAX_COUNT) 270 270 { 271 271 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pUserDataContainer->m_iPad] ); 271 271 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pUserDataContainer->m_iPad] ); 272 272 if(player != NULL && player->inventory->getCarried() != NULL) 273 273 { 274 274 iCount = player->inventory->getCarried()->count; ··· 309 309 } 310 310 else if(pThisUserDataContainer->m_iPad >= 0 && pThisUserDataContainer->m_iPad < XUSER_MAX_COUNT) 311 311 { 312 312 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pThisUserDataContainer->m_iPad] ); 312 312 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pThisUserDataContainer->m_iPad] ); 313 313 if(player != NULL && player->inventory->getCarried() != NULL) 314 314 { 315 315 iThisID = player->inventory->getCarried()->id; ··· 336 336 } 337 337 else if(pOtherUserDataContainer->m_iPad >= 0 && pOtherUserDataContainer->m_iPad < XUSER_MAX_COUNT) 338 338 { 339 339 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pOtherUserDataContainer->m_iPad] ); 339 339 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( Minecraft::GetInstance()->localplayers[pOtherUserDataContainer->m_iPad] ); 340 340 if(player != NULL && player->inventory->getCarried() != NULL) 341 341 { 342 342 iOtherID = player->inventory->getCarried()->id;

+9 -9

Minecraft.Client/Common/XUI/XUI_DebugOverlay.cpp

··· 28 28 #include "..\..\..\Minecraft.World\net.minecraft.commands.common.h" 29 29 #include "..\..\..\Minecraft.World\ConsoleSaveFileOriginal.h" 30 30 31 31 - #ifdef _DEBUG_MENUS_ENABLED 31 31 + #ifdef _DEBUG_MENUS_ENABLED 32 32 HRESULT CScene_DebugOverlay::OnInit( XUIMessageInit *pInitData, BOOL &bHandled ) 33 33 { 34 34 MapChildControls(); ··· 53 53 m_enchantmentIds.push_back(ench->id); 54 54 m_enchantments.SetText( i, app.GetString( ench->getDescriptionId() ) ); 55 55 } 56 56 - 56 56 + 57 57 m_mobs.InsertItems( 0, 21 ); 58 58 59 59 m_mobs.SetText( m_mobFactories.size(), L"Chicken" ); ··· 98 98 m_mobFactories.push_back(eTYPE_BLAZE); 99 99 m_mobs.SetText( m_mobFactories.size(), L"Magma Cube" ); 100 100 m_mobFactories.push_back(eTYPE_LAVASLIME); 101 101 - 101 101 + 102 102 103 103 Minecraft *pMinecraft = Minecraft::GetInstance(); 104 104 m_setTime.SetValue( pMinecraft->level->getLevelData()->getTime() % 24000 ); ··· 128 128 int id = m_itemIds[nIndex]; 129 129 //app.SetXuiServerAction(pNotifyPressData->UserIndex, eXuiServerAction_DropItem, (void *)id); 130 130 ClientConnection *conn = Minecraft::GetInstance()->getConnection(ProfileManager.GetPrimaryPad()); 131 131 - conn->send( GiveItemCommand::preparePacket(std::dynamic_pointer_cast<Player>(Minecraft::GetInstance()->localplayers[ProfileManager.GetPrimaryPad()]), id) ); 131 131 + conn->send( GiveItemCommand::preparePacket(dynamic_pointer_cast<Player>(Minecraft::GetInstance()->localplayers[ProfileManager.GetPrimaryPad()]), id) ); 132 132 } 133 133 } 134 134 else if ( hObjPressed == m_mobs ) 135 135 { 136 136 nIndex = m_mobs.GetCurSel(); 137 137 if(nIndex<m_mobFactories.size()) 138 138 - { 138 138 + { 139 139 app.SetXuiServerAction(ProfileManager.GetPrimaryPad(),eXuiServerAction_SpawnMob,(void *)m_mobFactories[nIndex]); 140 140 } 141 141 } ··· 143 143 { 144 144 nIndex = m_enchantments.GetCurSel(); 145 145 ClientConnection *conn = Minecraft::GetInstance()->getConnection(ProfileManager.GetPrimaryPad()); 146 146 - conn->send( EnchantItemCommand::preparePacket(std::dynamic_pointer_cast<Player>(Minecraft::GetInstance()->localplayers[ProfileManager.GetPrimaryPad()]), m_enchantmentIds[nIndex]) ); 146 146 + conn->send( EnchantItemCommand::preparePacket(dynamic_pointer_cast<Player>(Minecraft::GetInstance()->localplayers[ProfileManager.GetPrimaryPad()]), m_enchantmentIds[nIndex]) ); 147 147 } 148 148 /*else if( hObjPressed == m_saveToDisc ) // 4J-JEV: Doesn't look like we use this debug option anymore. 149 149 { ··· 171 171 HXUIOBJ hScene; 172 172 HRESULT hr; 173 173 //const WCHAR XZP_SEPARATOR = L'#'; 174 174 - const DWORD LOCATOR_SIZE = 256; // Use this to allocate space to hold a ResourceLocator string 174 174 + const DWORD LOCATOR_SIZE = 256; // Use this to allocate space to hold a ResourceLocator string 175 175 WCHAR szResourceLocator[ LOCATOR_SIZE ]; 176 176 177 177 swprintf(szResourceLocator, LOCATOR_SIZE, L"section://%X,%ls#%ls",c_ModuleHandle,L"media", L"media/"); ··· 189 189 HXUIOBJ hScene; 190 190 HRESULT hr; 191 191 //const WCHAR XZP_SEPARATOR = L'#'; 192 192 - const DWORD LOCATOR_SIZE = 256; // Use this to allocate space to hold a ResourceLocator string 192 192 + const DWORD LOCATOR_SIZE = 256; // Use this to allocate space to hold a ResourceLocator string 193 193 WCHAR szResourceLocator[ LOCATOR_SIZE ]; 194 194 195 195 swprintf(szResourceLocator, LOCATOR_SIZE, L"section://%X,%ls#%ls",c_ModuleHandle,L"media", L"media/"); ··· 256 256 if( hObjSource == m_setTime ) 257 257 { 258 258 Minecraft *pMinecraft = Minecraft::GetInstance(); 259 259 - 259 259 + 260 260 // Need to set the time on both levels to stop the flickering as the local level 261 261 // tries to predict the time 262 262 // Only works if we are on the host machine, but shouldn't break if not

+1 -1

Minecraft.Client/CraftingScreen.cpp

··· 11 11 void CraftingScreen::removed() 12 12 { 13 13 AbstractContainerScreen::removed(); 14 14 - menu->removed(std::dynamic_pointer_cast<Player>(minecraft->player)); 14 14 + menu->removed(dynamic_pointer_cast<Player>(minecraft->player)); 15 15 } 16 16 17 17 void CraftingScreen::renderLabels()

+3 -3

Minecraft.Client/CreeperRenderer.cpp

··· 11 11 12 12 void CreeperRenderer::scale(std::shared_ptr<Mob> mob, float a) 13 13 { 14 14 - std::shared_ptr<Creeper> creeper = std::dynamic_pointer_cast<Creeper>(mob); 14 14 + std::shared_ptr<Creeper> creeper = dynamic_pointer_cast<Creeper>(mob); 15 15 16 16 float g = creeper->getSwelling(a); 17 17 ··· 27 27 28 28 int CreeperRenderer::getOverlayColor(std::shared_ptr<Mob> mob, float br, float a) 29 29 { 30 30 - std::shared_ptr<Creeper> creeper = std::dynamic_pointer_cast<Creeper>(mob); 30 30 + std::shared_ptr<Creeper> creeper = dynamic_pointer_cast<Creeper>(mob); 31 31 32 32 float step = creeper->getSwelling(a); 33 33 ··· 47 47 int CreeperRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a) 48 48 { 49 49 // 4J - dynamic cast required because we aren't using templates/generics in our version 50 50 - std::shared_ptr<Creeper> mob = std::dynamic_pointer_cast<Creeper>(_mob); 50 50 + std::shared_ptr<Creeper> mob = dynamic_pointer_cast<Creeper>(_mob); 51 51 if (mob->isPowered()) 52 52 { 53 53 if (mob->isInvisible()) glDepthMask(false);

+1 -1

Minecraft.Client/DragonModel.cpp

··· 114 114 void DragonModel::render(std::shared_ptr<Entity> entity, float time, float r, float bob, float yRot, float xRot, float scale, bool usecompiled) 115 115 { 116 116 glPushMatrix(); 117 117 - std::shared_ptr<EnderDragon> dragon = std::dynamic_pointer_cast<EnderDragon>(entity); 117 117 + std::shared_ptr<EnderDragon> dragon = dynamic_pointer_cast<EnderDragon>(entity); 118 118 119 119 float ttt = dragon->oFlapTime + (dragon->flapTime - dragon->oFlapTime) * a; 120 120 jaw->xRot = (float) (Mth::sin(ttt * PI * 2) + 1) * 0.2f;

+1 -1

Minecraft.Client/EnchantTableRenderer.cpp

··· 17 17 void EnchantTableRenderer::render(std::shared_ptr<TileEntity> _table, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled) 18 18 { 19 19 // 4J Convert as we aren't using a templated class 20 20 - std::shared_ptr<EnchantmentTableEntity> table = std::dynamic_pointer_cast<EnchantmentTableEntity>(_table); 20 20 + std::shared_ptr<EnchantmentTableEntity> table = dynamic_pointer_cast<EnchantmentTableEntity>(_table); 21 21 22 22 #ifdef __PSVITA__ 23 23 // 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

+1 -1

Minecraft.Client/EnderChestRenderer.cpp

··· 6 6 void EnderChestRenderer::render(std::shared_ptr<TileEntity> _chest, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled) 7 7 { 8 8 // 4J Convert as we aren't using a templated class 9 9 - std::shared_ptr<EnderChestTileEntity> chest = std::dynamic_pointer_cast<EnderChestTileEntity>(_chest); 9 9 + std::shared_ptr<EnderChestTileEntity> chest = dynamic_pointer_cast<EnderChestTileEntity>(_chest); 10 10 11 11 int data = 0; 12 12

+1 -1

Minecraft.Client/EnderCrystalRenderer.cpp

··· 13 13 { 14 14 // 4J - original version used generics and thus had an input parameter of type EnderCrystal rather than std::shared_ptr<Entity> we have here - 15 15 // do some casting around instead 16 16 - std::shared_ptr<EnderCrystal> crystal = std::dynamic_pointer_cast<EnderCrystal>(_crystal); 16 16 + std::shared_ptr<EnderCrystal> crystal = dynamic_pointer_cast<EnderCrystal>(_crystal); 17 17 if (currentModel != EnderCrystalModel::MODEL_ID) 18 18 { 19 19 model = new EnderCrystalModel(0);

+5 -5

Minecraft.Client/EnderDragonRenderer.cpp

··· 18 18 void EnderDragonRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a) 19 19 { 20 20 // 4J - dynamic cast required because we aren't using templates/generics in our version 21 21 - std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob); 21 21 + std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob); 22 22 23 23 // 4J - reorganised a bit so we can free allocations 24 24 double lpComponents[3]; ··· 49 49 void EnderDragonRenderer::renderModel(std::shared_ptr<Entity> _mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale) 50 50 { 51 51 // 4J - dynamic cast required because we aren't using templates/generics in our version 52 52 - std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob); 52 52 + std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob); 53 53 54 54 if (mob->dragonDeathTime > 0) 55 55 { ··· 90 90 void EnderDragonRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a) 91 91 { 92 92 // 4J - dynamic cast required because we aren't using templates/generics in our version 93 93 - std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob); 93 93 + std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob); 94 94 EnderDragonRenderer::bossInstance = mob; 95 95 if (currentModel != DragonModel::MODEL_ID) 96 96 { ··· 170 170 void EnderDragonRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a) 171 171 { 172 172 // 4J - dynamic cast required because we aren't using templates/generics in our version 173 173 - std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob); 173 173 + std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob); 174 174 MobRenderer::additionalRendering(mob, a); 175 175 Tesselator *t = Tesselator::getInstance(); 176 176 ··· 230 230 int EnderDragonRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a) 231 231 { 232 232 // 4J - dynamic cast required because we aren't using templates/generics in our version 233 233 - std::shared_ptr<EnderDragon> mob = std::dynamic_pointer_cast<EnderDragon>(_mob); 233 233 + std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob); 234 234 235 235 if (layer == 1) 236 236 {

+3 -3

Minecraft.Client/EndermanRenderer.cpp

··· 14 14 { 15 15 // 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity> we have here - 16 16 // do some casting around instead 17 17 - std::shared_ptr<EnderMan> mob = std::dynamic_pointer_cast<EnderMan>(_mob); 17 17 + std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob); 18 18 19 19 model->carrying = mob->getCarryingTile() > 0; 20 20 model->creepy = mob->isCreepy(); ··· 33 33 { 34 34 // 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity> we have here - 35 35 // do some casting around instead 36 36 - std::shared_ptr<EnderMan> mob = std::dynamic_pointer_cast<EnderMan>(_mob); 36 36 + std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob); 37 37 38 38 MobRenderer::additionalRendering(_mob, a); 39 39 ··· 72 72 { 73 73 // 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity> we have here - 74 74 // do some casting around instead 75 75 - std::shared_ptr<EnderMan> mob = std::dynamic_pointer_cast<EnderMan>(_mob); 75 75 + std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob); 76 76 77 77 if (layer != 0) return -1; 78 78

+1 -1

Minecraft.Client/EntityRenderDispatcher.cpp

··· 197 197 playerRotX = player->xRotO + (player->xRot - player->xRotO) * a; 198 198 } 199 199 200 200 - std::shared_ptr<Player> pl = std::dynamic_pointer_cast<Player>(player); 200 200 + std::shared_ptr<Player> pl = dynamic_pointer_cast<Player>(player); 201 201 if (pl->ThirdPersonView() == 2) 202 202 { 203 203 playerRotY += 180;

+5 -5

Minecraft.Client/EntityRenderer.cpp

··· 160 160 161 161 glDepthMask(false); 162 162 float r = shadowRadius; 163 163 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(e); 163 163 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e); 164 164 bool isLocalPlayer = false; 165 165 float fYLocalPlayerShadowOffset=0.0f; 166 166 167 167 - //if (std::dynamic_pointer_cast<Mob>(e) != NULL) 167 167 + //if (dynamic_pointer_cast<Mob>(e) != NULL) 168 168 if (mob != NULL) 169 169 { 170 170 - //std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(e); 170 170 + //std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e); 171 171 r *= mob->getSizeScale(); 172 172 173 173 - std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(mob); 173 173 + std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(mob); 174 174 if (animal != NULL) 175 175 { 176 176 if (animal->isBaby()) ··· 179 179 } 180 180 } 181 181 182 182 - if(std::dynamic_pointer_cast<LocalPlayer>(mob)!=NULL) 182 182 + if(dynamic_pointer_cast<LocalPlayer>(mob)!=NULL) 183 183 { 184 184 isLocalPlayer=true; 185 185 }

+6 -6

Minecraft.Client/EntityTracker.cpp

··· 31 31 if (e->GetType() == eTYPE_SERVERPLAYER) 32 32 { 33 33 addEntity(e, 32 * 16, 2); 34 34 - std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e); 34 34 + std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e); 35 35 for( AUTO_VAR(it, entities.begin()); it != entities.end(); it++ ) 36 36 { 37 37 if( (*it)->e != player ) ··· 55 55 else if (e->GetType() == eTYPE_MINECART) addEntity(e, 16 * 5, 3, true); 56 56 else if (e->GetType() == eTYPE_BOAT) addEntity(e, 16 * 5, 3, true); 57 57 else if (e->GetType() == eTYPE_SQUID) addEntity(e, 16 * 4, 3, true); 58 58 - else if (std::dynamic_pointer_cast<Creature>(e)!=NULL) addEntity(e, 16 * 5, 3, true); 58 58 + else if (dynamic_pointer_cast<Creature>(e)!=NULL) addEntity(e, 16 * 5, 3, true); 59 59 else if (e->GetType() == eTYPE_ENDERDRAGON ) addEntity(e, 16 * 10, 3, true); 60 60 else if (e->GetType() == eTYPE_PRIMEDTNT) addEntity(e, 16 * 10, 10, true); 61 61 else if (e->GetType() == eTYPE_FALLINGTILE) addEntity(e, 16 * 10, 20, true); ··· 105 105 { 106 106 if (e->GetType() == eTYPE_SERVERPLAYER) 107 107 { 108 108 - std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e); 108 108 + std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e); 109 109 for( AUTO_VAR(it, entities.begin()); it != entities.end(); it++ ) 110 110 { 111 111 (*it)->removePlayer(player); ··· 115 115 116 116 void EntityTracker::tick() 117 117 { 118 118 - std::vector<std::shared_ptr<ServerPlayer> > movedPlayers; 118 118 + vector<std::shared_ptr<ServerPlayer> > movedPlayers; 119 119 for( AUTO_VAR(it, entities.begin()); it != entities.end(); it++ ) 120 120 { 121 121 std::shared_ptr<TrackedEntity> te = *it; 122 122 te->tick(this, &level->players); 123 123 if (te->moved && te->e->GetType() == eTYPE_SERVERPLAYER) 124 124 { 125 125 - movedPlayers.push_back(std::dynamic_pointer_cast<ServerPlayer>(te->e)); 125 125 + movedPlayers.push_back(dynamic_pointer_cast<ServerPlayer>(te->e)); 126 126 } 127 127 } 128 128 ··· 174 174 // 4J Stu - We want to do this for dead players as they don't tick normally 175 175 for(AUTO_VAR(it, level->players.begin()); it != level->players.end(); ++it) 176 176 { 177 177 - std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(*it); 177 177 + std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(*it); 178 178 if(!player->isAlive()) 179 179 { 180 180 player->flushEntitiesToRemove();

+1 -1

Minecraft.Client/ExperienceOrbRenderer.cpp

··· 21 21 22 22 void ExperienceOrbRenderer::render(std::shared_ptr<Entity> _orb, double x, double y, double z, float rot, float a) 23 23 { 24 24 - std::shared_ptr<ExperienceOrb> orb = std::dynamic_pointer_cast<ExperienceOrb>(_orb); 24 24 + std::shared_ptr<ExperienceOrb> orb = dynamic_pointer_cast<ExperienceOrb>(_orb); 25 25 glPushMatrix(); 26 26 glTranslatef((float) x, (float) y, (float) z); 27 27

+1 -1

Minecraft.Client/FallingTileRenderer.cpp

··· 15 15 void FallingTileRenderer::render(std::shared_ptr<Entity> _tile, double x, double y, double z, float rot, float a) 16 16 { 17 17 // 4J - dynamic cast required because we aren't using templates/generics in our version 18 18 - std::shared_ptr<FallingTile> tile = std::dynamic_pointer_cast<FallingTile>(_tile); 18 18 + std::shared_ptr<FallingTile> tile = dynamic_pointer_cast<FallingTile>(_tile); 19 19 glPushMatrix(); 20 20 glTranslatef((float) x, (float) y, (float) z); 21 21

+1 -1

Minecraft.Client/FireballRenderer.cpp

··· 15 15 void FireballRenderer::render(std::shared_ptr<Entity> _fireball, double x, double y, double z, float rot, float a) 16 16 { 17 17 // 4J - dynamic cast required because we aren't using templates/generics in our version 18 18 - std::shared_ptr<Fireball> fireball = std::dynamic_pointer_cast<Fireball>(_fireball); 18 18 + std::shared_ptr<Fireball> fireball = dynamic_pointer_cast<Fireball>(_fireball); 19 19 20 20 glPushMatrix(); 21 21

+2 -2

Minecraft.Client/FishingHookRenderer.cpp

··· 11 11 void FishingHookRenderer::render(std::shared_ptr<Entity> _hook, double x, double y, double z, float rot, float a) 12 12 { 13 13 // 4J - dynamic cast required because we aren't using templates/generics in our version 14 14 - std::shared_ptr<FishingHook> hook = std::dynamic_pointer_cast<FishingHook>(_hook); 14 14 + std::shared_ptr<FishingHook> hook = dynamic_pointer_cast<FishingHook>(_hook); 15 15 16 16 glPushMatrix(); 17 17 ··· 62 62 double xp = hook->owner->xo + (hook->owner->x - hook->owner->xo) * a + vv->x; 63 63 double yp = hook->owner->yo + (hook->owner->y - hook->owner->yo) * a + vv->y; 64 64 double zp = hook->owner->zo + (hook->owner->z - hook->owner->zo) * a + vv->z; 65 65 - double yOffset = hook->owner != std::dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player) ? hook->owner->getHeadHeight() : 0; 65 65 + double yOffset = hook->owner != dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player) ? hook->owner->getHeadHeight() : 0; 66 66 67 67 // 4J-PB - changing this to be per player 68 68 //if (this->entityRenderDispatcher->options->thirdPersonView)

+14 -14

Minecraft.Client/GameRenderer.cpp

··· 276 276 277 277 if (mc->cameraTargetPlayer == NULL) 278 278 { 279 279 - mc->cameraTargetPlayer = std::dynamic_pointer_cast<Mob>(mc->player); 279 279 + mc->cameraTargetPlayer = dynamic_pointer_cast<Mob>(mc->player); 280 280 } 281 281 282 282 float brr = mc->level->getBrightness(Mth::floor(mc->cameraTargetPlayer->x), Mth::floor(mc->cameraTargetPlayer->y), Mth::floor(mc->cameraTargetPlayer->z)); ··· 407 407 408 408 void GameRenderer::tickFov() 409 409 { 410 410 - std::shared_ptr<LocalPlayer>player = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer); 410 410 + std::shared_ptr<LocalPlayer>player = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer); 411 411 412 412 int playerIdx = player ? player->GetXboxPad() : 0; 413 413 tFov[playerIdx] = player->getFieldOfViewModifier(); ··· 420 420 { 421 421 if (cameraFlip > 0 ) return 90; 422 422 423 423 - std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer); 423 423 + std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer); 424 424 int playerIdx = player ? player->GetXboxPad() : 0; 425 425 float fov = m_fov;//70; 426 426 if (applyEffects) ··· 470 470 471 471 void GameRenderer::bobView(float a) 472 472 { 473 473 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mc->cameraTargetPlayer); 473 473 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mc->cameraTargetPlayer); 474 474 if(player==NULL) 475 475 { 476 476 return; 477 477 } 478 478 - //std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mc->cameraTargetPlayer); 478 478 + //std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mc->cameraTargetPlayer); 479 479 480 480 float wda = player->walkDist - player->walkDistO; 481 481 float b = -(player->walkDist + wda * a); ··· 490 490 void GameRenderer::moveCameraToPlayer(float a) 491 491 { 492 492 std::shared_ptr<Mob> player = mc->cameraTargetPlayer; 493 493 - std::shared_ptr<LocalPlayer> localplayer = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer); 493 493 + std::shared_ptr<LocalPlayer> localplayer = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer); 494 494 float heightOffset = player->heightOffset - 1.62f; 495 495 496 496 double x = player->xo + (player->x - player->xo) * a; ··· 719 719 { 720 720 if (cameraFlip > 0) return; 721 721 722 722 - std::shared_ptr<LocalPlayer> localplayer = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer); 722 722 + std::shared_ptr<LocalPlayer> localplayer = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer); 723 723 724 724 // 4J-PB - to turn off the hand for screenshots, but not when the item held is a map 725 725 if ( localplayer!=NULL) ··· 1383 1383 PIXEndNamedEvent(); 1384 1384 turnOffLightLayer(a); // 4J - brought forward from 1.8.2 1385 1385 1386 1386 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(cameraEntity); 1386 1386 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(cameraEntity); 1387 1387 if (mc->hitResult != NULL && cameraEntity->isUnderLiquid(Material::water) && player!=NULL) //&& !mc->options.hideGui) 1388 1388 { 1389 1389 - //std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(cameraEntity); 1389 1389 + //std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(cameraEntity); 1390 1390 glDisable(GL_ALPHA_TEST); 1391 1391 levelRenderer->renderHit(player, mc->hitResult, 0, player->inventory->getSelected(), a); 1392 1392 levelRenderer->renderHitOutline(player, mc->hitResult, 0, player->inventory->getSelected(), a); ··· 1441 1441 glEnable(GL_CULL_FACE); 1442 1442 glDisable(GL_BLEND); 1443 1443 1444 1444 - if (zoom == 1 && (std::dynamic_pointer_cast<Player>(cameraEntity)!=NULL)) //&& !mc->options.hideGui) 1444 1444 + if (zoom == 1 && (dynamic_pointer_cast<Player>(cameraEntity)!=NULL)) //&& !mc->options.hideGui) 1445 1445 { 1446 1446 if (mc->hitResult != NULL && !cameraEntity->isUnderLiquid(Material::water)) 1447 1447 { 1448 1448 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(cameraEntity); 1448 1448 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(cameraEntity); 1449 1449 glDisable(GL_ALPHA_TEST); 1450 1450 levelRenderer->renderHit(player, mc->hitResult, 0, player->inventory->getSelected(), a); 1451 1451 levelRenderer->renderHitOutline(player, mc->hitResult, 0, player->inventory->getSelected(), a); ··· 1462 1462 1463 1463 glEnable(GL_BLEND); 1464 1464 glBlendFunc(GL_SRC_ALPHA, GL_ONE); 1465 1465 - levelRenderer->renderDestroyAnimation(Tesselator::getInstance(), std::dynamic_pointer_cast<Player>(cameraEntity), a); 1465 1465 + levelRenderer->renderDestroyAnimation(Tesselator::getInstance(), dynamic_pointer_cast<Player>(cameraEntity), a); 1466 1466 glDisable(GL_BLEND); 1467 1467 1468 1468 if (mc->options->isCloudsOn()) ··· 1957 1957 1958 1958 // 4J - check for creative mode brought forward from 1.2.3 1959 1959 bool creative = false; 1960 1960 - if (std::dynamic_pointer_cast<Player>(player) ) 1960 1960 + if (dynamic_pointer_cast<Player>(player) ) 1961 1961 { 1962 1962 - creative = (std::dynamic_pointer_cast<Player>(player))->abilities.instabuild; 1962 1962 + creative = (dynamic_pointer_cast<Player>(player))->abilities.instabuild; 1963 1963 } 1964 1964 1965 1965 if (i == 999)

+1 -1

Minecraft.Client/GhastRenderer.cpp

··· 9 9 10 10 void GhastRenderer::scale(std::shared_ptr<Mob> mob, float a) 11 11 { 12 12 - std::shared_ptr<Ghast> ghast = std::dynamic_pointer_cast<Ghast>(mob); 12 12 + std::shared_ptr<Ghast> ghast = dynamic_pointer_cast<Ghast>(mob); 13 13 14 14 float ss = (ghast->oCharge+(ghast->charge-ghast->oCharge)*a)/20.0f; 15 15 if (ss<0) ss = 0;

+1 -1

Minecraft.Client/ItemFrameRenderer.cpp

··· 27 27 { 28 28 // 4J - original version used generics and thus had an input parameter of type EnderCrystal rather than std::shared_ptr<Entity> we have here - 29 29 // do some casting around instead 30 30 - std::shared_ptr<ItemFrame> itemFrame = std::dynamic_pointer_cast<ItemFrame>(_itemframe); 30 30 + std::shared_ptr<ItemFrame> itemFrame = dynamic_pointer_cast<ItemFrame>(_itemframe); 31 31 32 32 glPushMatrix(); 33 33 float xOffs = (float) (itemFrame->x - x) - 0.5f;

+1 -1

Minecraft.Client/ItemInHandRenderer.cpp

··· 319 319 float fudgeY = 0.0f; 320 320 float fudgeZ = 0.0f; 321 321 bool splitHoriz = false; 322 322 - std::shared_ptr<LocalPlayer> localPlayer = std::dynamic_pointer_cast<LocalPlayer>(player); 322 322 + std::shared_ptr<LocalPlayer> localPlayer = dynamic_pointer_cast<LocalPlayer>(player); 323 323 if( localPlayer ) 324 324 { 325 325 if( localPlayer->m_iScreenSection == C4JRender::VIEWPORT_TYPE_SPLIT_BOTTOM ||

+1 -1

Minecraft.Client/ItemRenderer.cpp

··· 32 32 void ItemRenderer::render(std::shared_ptr<Entity> _itemEntity, double x, double y, double z, float rot, float a) 33 33 { 34 34 // 4J - dynamic cast required because we aren't using templates/generics in our version 35 35 - std::shared_ptr<ItemEntity> itemEntity = std::dynamic_pointer_cast<ItemEntity>(_itemEntity); 35 35 + std::shared_ptr<ItemEntity> itemEntity = dynamic_pointer_cast<ItemEntity>(_itemEntity); 36 36 37 37 random->setSeed(187); 38 38 std::shared_ptr<ItemInstance> item = itemEntity->getItem();

+1 -1

Minecraft.Client/ItemSpriteRenderer.cpp

··· 37 37 if (icon == PotionItem::getTexture(PotionItem::THROWABLE_ICON) ) 38 38 { 39 39 40 40 - int col = PotionBrewing::getColorValue((std::dynamic_pointer_cast<ThrownPotion>(e) )->getPotionValue(), false); 40 40 + int col = PotionBrewing::getColorValue((dynamic_pointer_cast<ThrownPotion>(e) )->getPotionValue(), false); 41 41 float red = ((col >> 16) & 0xff) / 255.0f; 42 42 float g = ((col >> 8) & 0xff) / 255.0f; 43 43 float b = ((col) & 0xff) / 255.0f;

+1 -1

Minecraft.Client/LavaSlimeModel.cpp

··· 43 43 44 44 void LavaSlimeModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r, float a) 45 45 { 46 46 - std::shared_ptr<LavaSlime> lavaSlime = std::dynamic_pointer_cast<LavaSlime>(mob); 46 46 + std::shared_ptr<LavaSlime> lavaSlime = dynamic_pointer_cast<LavaSlime>(mob); 47 47 48 48 float slimeSquish = (lavaSlime->oSquish + (lavaSlime->squish - lavaSlime->oSquish) * a); 49 49 if (slimeSquish < 0)

+2 -2

Minecraft.Client/LavaSlimeRenderer.cpp

··· 12 12 { 13 13 // 4J - original version used generics and thus had an input parameter of type LavaSlime rather than std::shared_ptr<Entity> we have here - 14 14 // do some casting around instead 15 15 - std::shared_ptr<LavaSlime> mob = std::dynamic_pointer_cast<LavaSlime>(_mob); 15 15 + std::shared_ptr<LavaSlime> mob = dynamic_pointer_cast<LavaSlime>(_mob); 16 16 int modelVersion = ((LavaSlimeModel *) model)->getModelVersion(); 17 17 if (modelVersion != this->modelVersion) 18 18 { ··· 27 27 { 28 28 // 4J - original version used generics and thus had an input parameter of type LavaSlime rather than std::shared_ptr<Mob> we have here - 29 29 // do some casting around instead 30 30 - std::shared_ptr<LavaSlime> slime = std::dynamic_pointer_cast<LavaSlime>(_slime); 30 30 + std::shared_ptr<LavaSlime> slime = dynamic_pointer_cast<LavaSlime>(_slime); 31 31 int size = slime->getSize(); 32 32 float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1); 33 33 float w = 1 / (ss + 1);

+3 -3

Minecraft.Client/LevelRenderer.cpp

··· 540 540 { 541 541 // 4J-PB - changing this to be per player 542 542 //if (entity == mc->cameraTargetPlayer && !mc->options->thirdPersonView && !mc->cameraTargetPlayer->isSleeping()) continue; 543 543 - std::shared_ptr<LocalPlayer> localplayer = std::dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer); 543 543 + std::shared_ptr<LocalPlayer> localplayer = dynamic_pointer_cast<LocalPlayer>(mc->cameraTargetPlayer); 544 544 545 545 if (localplayer && entity == mc->cameraTargetPlayer && !localplayer->ThirdPersonView() && !mc->cameraTargetPlayer->isSleeping()) continue; 546 546 ··· 2788 2788 break; 2789 2789 case eParticleType_instantSpell: 2790 2790 particle = std::shared_ptr<Particle>(new SpellParticle(lev, x, y, z, xa, ya, za)); 2791 2791 - std::dynamic_pointer_cast<SpellParticle>(particle)->setBaseTex(9 * 16); 2791 2791 + dynamic_pointer_cast<SpellParticle>(particle)->setBaseTex(9 * 16); 2792 2792 break; 2793 2793 case eParticleType_note: 2794 2794 particle = std::shared_ptr<Particle>( new NoteParticle(lev, x, y, z, xa, ya, za) ); ··· 2863 2863 else if( ( eParticleType >= eParticleType_tilecrack_base ) && ( eParticleType <= eParticleType_tilecrack_last ) ) 2864 2864 { 2865 2865 int id = PARTICLE_CRACK_ID(eParticleType), data = PARTICLE_CRACK_DATA(eParticleType); 2866 2866 - 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) ); 2866 2866 + 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) ); 2867 2867 } 2868 2868 } 2869 2869

+1 -1

Minecraft.Client/LightningBoltRenderer.cpp

··· 6 6 void LightningBoltRenderer::render(std::shared_ptr<Entity> _bolt, double x, double y, double z, float rot, float a) 7 7 { 8 8 // 4J - dynamic cast required because we aren't using templates/generics in our version 9 9 - std::shared_ptr<LightningBolt> bolt = std::dynamic_pointer_cast<LightningBolt>(_bolt); 9 9 + std::shared_ptr<LightningBolt> bolt = dynamic_pointer_cast<LightningBolt>(_bolt); 10 10 11 11 Tesselator *t = Tesselator::getInstance(); 12 12

+7 -7

Minecraft.Client/LocalPlayer.cpp

··· 277 277 float sprintForward = input->sprintForward; 278 278 279 279 bool wasRunning = sprintForward >= runTreshold; 280 280 - //input->tick( std::dynamic_pointer_cast<Player>( shared_from_this() ) ); 280 280 + //input->tick( dynamic_pointer_cast<Player>( shared_from_this() ) ); 281 281 // 4J-PB - make it a localplayer 282 282 input->tick( this ); 283 283 sprintForward = input->sprintForward; ··· 622 622 623 623 bool LocalPlayer::startCrafting(int x, int y, int z) 624 624 { 625 625 - bool success = app.LoadCrafting3x3Menu(GetXboxPad(), std::dynamic_pointer_cast<LocalPlayer>( shared_from_this() ), x, y, z ); 625 625 + bool success = app.LoadCrafting3x3Menu(GetXboxPad(), dynamic_pointer_cast<LocalPlayer>( shared_from_this() ), x, y, z ); 626 626 if( success ) ui.PlayUISFX(eSFX_Press); 627 627 //app.LoadXuiCraftMenu(0,inventory, level, x, y, z); 628 628 //minecraft->setScreen(new CraftingScreen(inventory, level, x, y, z)); ··· 766 766 && ProfileManager.IsFullVersion() 767 767 ) 768 768 { 769 769 - stat->handleParamBlob(std::dynamic_pointer_cast<LocalPlayer>(shared_from_this()), param); 769 769 + stat->handleParamBlob(dynamic_pointer_cast<LocalPlayer>(shared_from_this()), param); 770 770 } 771 771 delete [] param.data; 772 772 #else ··· 1430 1430 if(lastClickState == lastClick_oldRepeat) return false; 1431 1431 1432 1432 1433 1433 - std::shared_ptr<MultiplayerLocalPlayer> mplp = std::dynamic_pointer_cast<MultiplayerLocalPlayer>( shared_from_this() ); 1433 1433 + std::shared_ptr<MultiplayerLocalPlayer> mplp = dynamic_pointer_cast<MultiplayerLocalPlayer>( shared_from_this() ); 1434 1434 1435 1435 if(mplp && mplp->connection) mplp->StopSleeping(); 1436 1436 ··· 1550 1550 { 1551 1551 app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_MAP); 1552 1552 } 1553 1553 - else if(riding != NULL && std::dynamic_pointer_cast<Minecart>(riding) != NULL) 1553 1553 + else if(riding != NULL && dynamic_pointer_cast<Minecart>(riding) != NULL) 1554 1554 { 1555 1555 app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_RIDING_MINECART); 1556 1556 } 1557 1557 - else if(riding != NULL && std::dynamic_pointer_cast<Boat>(riding) != NULL) 1557 1557 + else if(riding != NULL && dynamic_pointer_cast<Boat>(riding) != NULL) 1558 1558 { 1559 1559 app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_BOATING); 1560 1560 } 1561 1561 - else if(riding != NULL && std::dynamic_pointer_cast<Pig>(riding) != NULL) 1561 1561 + else if(riding != NULL && dynamic_pointer_cast<Pig>(riding) != NULL) 1562 1562 { 1563 1563 app.SetRichPresenceContext(m_iPad,CONTEXT_GAME_STATE_RIDING_PIG); 1564 1564 }

+1 -1

Minecraft.Client/MinecartRenderer.cpp

··· 13 13 void MinecartRenderer::render(std::shared_ptr<Entity> _cart, double x, double y, double z, float rot, float a) 14 14 { 15 15 // 4J - dynamic cast required because we aren't using templates/generics in our version 16 16 - std::shared_ptr<Minecart> cart = std::dynamic_pointer_cast<Minecart>(_cart); 16 16 + std::shared_ptr<Minecart> cart = dynamic_pointer_cast<Minecart>(_cart); 17 17 18 18 glPushMatrix(); 19 19

+26 -26

Minecraft.Client/Minecraft.cpp

··· 2810 2810 { 2811 2811 default: 2812 2812 { 2813 2813 - std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity); 2813 2813 + std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity); 2814 2814 2815 2815 if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem)) 2816 2816 { ··· 2839 2839 break; 2840 2840 default: 2841 2841 { 2842 2842 - std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity); 2842 2842 + std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity); 2843 2843 2844 2844 if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem)) 2845 2845 { ··· 2870 2870 case Item::shears_Id: 2871 2871 { 2872 2872 if(player->isAllowedToAttackAnimals()) *piAction=IDS_TOOLTIPS_HIT; 2873 2873 - std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity); 2873 2873 + std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity); 2874 2874 if(!animal->isBaby()) *piUse=IDS_TOOLTIPS_SHEAR; 2875 2875 } 2876 2876 break; 2877 2877 default: 2878 2878 { 2879 2879 - std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity); 2879 2879 + std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity); 2880 2880 2881 2881 if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem)) 2882 2882 { ··· 2898 2898 *piAction=IDS_TOOLTIPS_MINE; 2899 2899 2900 2900 // are we in the boat already? 2901 2901 - if (std::dynamic_pointer_cast<Boat>( player->riding ) != NULL) 2901 2901 + if (dynamic_pointer_cast<Boat>( player->riding ) != NULL) 2902 2902 { 2903 2903 *piUse=IDS_TOOLTIPS_EXIT; 2904 2904 } ··· 2910 2910 case eTYPE_MINECART: 2911 2911 *piAction=IDS_TOOLTIPS_MINE; 2912 2912 // are we in the minecart already? 2913 2913 - if (std::dynamic_pointer_cast<Minecart>( player->riding ) != NULL) 2913 2913 + if (dynamic_pointer_cast<Minecart>( player->riding ) != NULL) 2914 2914 { 2915 2915 *piUse=IDS_TOOLTIPS_EXIT; 2916 2916 } 2917 2917 else 2918 2918 { 2919 2919 - switch(std::dynamic_pointer_cast<Minecart>(hitResult->entity)->type) 2919 2919 + switch(dynamic_pointer_cast<Minecart>(hitResult->entity)->type) 2920 2920 { 2921 2921 case Minecart::RIDEABLE: 2922 2922 *piUse=IDS_TOOLTIPS_RIDE; ··· 2958 2958 { 2959 2959 case Item::dye_powder_Id: 2960 2960 { 2961 2961 - std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(hitResult->entity); 2961 2961 + std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(hitResult->entity); 2962 2962 // convert to tile-based color value (0 is white instead of black) 2963 2963 int newColor = ClothTile::getTileDataForItemAuxValue(heldItem->getAuxValue()); 2964 2964 ··· 2971 2971 break; 2972 2972 case Item::shears_Id: 2973 2973 { 2974 2974 - std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(hitResult->entity); 2974 2974 + std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(hitResult->entity); 2975 2975 2976 2976 // can only shear a sheep that hasn't been sheared 2977 2977 if(!sheep->isSheared() ) ··· 2983 2983 break; 2984 2984 default: 2985 2985 { 2986 2986 - std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity); 2986 2986 + std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity); 2987 2987 2988 2988 if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem)) 2989 2989 { ··· 2998 2998 case eTYPE_PIG: 2999 2999 // can ride a pig 3000 3000 if(player->isAllowedToAttackAnimals()) *piAction=IDS_TOOLTIPS_HIT; 3001 3001 - if (std::dynamic_pointer_cast<Pig>( player->riding ) != NULL) 3001 3001 + if (dynamic_pointer_cast<Pig>( player->riding ) != NULL) 3002 3002 { 3003 3003 *piUse=IDS_TOOLTIPS_EXIT; 3004 3004 } 3005 3005 else 3006 3006 { 3007 3007 // does the pig have a saddle? 3008 3008 - if(std::dynamic_pointer_cast<Pig>(hitResult->entity)->hasSaddle()) 3008 3008 + if(dynamic_pointer_cast<Pig>(hitResult->entity)->hasSaddle()) 3009 3009 { 3010 3010 *piUse=IDS_TOOLTIPS_RIDE; 3011 3011 } 3012 3012 - else if (!std::dynamic_pointer_cast<Pig>(hitResult->entity)->isBaby()) 3012 3012 + else if (!dynamic_pointer_cast<Pig>(hitResult->entity)->isBaby()) 3013 3013 { 3014 3014 if(player->inventory->IsHeldItem()) 3015 3015 { ··· 3023 3023 break; 3024 3024 default: 3025 3025 { 3026 3026 - std::shared_ptr<Animal> animal = std::dynamic_pointer_cast<Animal>(hitResult->entity); 3026 3026 + std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(hitResult->entity); 3027 3027 3028 3028 if(!animal->isBaby() && !animal->isInLove() && (animal->getAge() == 0) && animal->isFood(heldItem)) 3029 3029 { ··· 3042 3042 { 3043 3043 int iID=-1; 3044 3044 std::shared_ptr<ItemInstance> heldItem=nullptr; 3045 3045 - std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(hitResult->entity); 3045 3045 + std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(hitResult->entity); 3046 3046 3047 3047 if(player->inventory->IsHeldItem()) 3048 3048 { ··· 3132 3132 { 3133 3133 int iID=-1; 3134 3134 std::shared_ptr<ItemInstance> heldItem=nullptr; 3135 3135 - std::shared_ptr<Ozelot> ocelot = std::dynamic_pointer_cast<Ozelot>(hitResult->entity); 3135 3135 + std::shared_ptr<Ozelot> ocelot = dynamic_pointer_cast<Ozelot>(hitResult->entity); 3136 3136 3137 3137 if(player->inventory->IsHeldItem()) 3138 3138 { ··· 3193 3193 case eTYPE_PLAYER: 3194 3194 { 3195 3195 // Fix for #58576 - TU6: Content: Gameplay: Hit button prompt is available when attacking a host who has "Invisible" option turned on 3196 3196 - std::shared_ptr<Player> TargetPlayer = std::dynamic_pointer_cast<Player>(hitResult->entity); 3196 3196 + std::shared_ptr<Player> TargetPlayer = dynamic_pointer_cast<Player>(hitResult->entity); 3197 3197 3198 3198 if(!TargetPlayer->hasInvisiblePrivilege()) // This means they are invisible, not just that they have the privilege 3199 3199 { ··· 3206 3206 break; 3207 3207 case eTYPE_ITEM_FRAME: 3208 3208 { 3209 3209 - std::shared_ptr<ItemFrame> itemFrame = std::dynamic_pointer_cast<ItemFrame>(hitResult->entity); 3209 3209 + std::shared_ptr<ItemFrame> itemFrame = dynamic_pointer_cast<ItemFrame>(hitResult->entity); 3210 3210 3211 3211 // is the frame occupied? 3212 3212 if(itemFrame->getItem()!=NULL) ··· 3228 3228 break; 3229 3229 case eTYPE_VILLAGER: 3230 3230 { 3231 3231 - std::shared_ptr<Villager> villager = std::dynamic_pointer_cast<Villager>(hitResult->entity); 3231 3231 + std::shared_ptr<Villager> villager = dynamic_pointer_cast<Villager>(hitResult->entity); 3232 3232 if (!villager->isBaby()) 3233 3233 { 3234 3234 *piUse=IDS_TOOLTIPS_TRADE; ··· 3238 3238 break; 3239 3239 case eTYPE_ZOMBIE: 3240 3240 { 3241 3241 - std::shared_ptr<Zombie> zomb = std::dynamic_pointer_cast<Zombie>(hitResult->entity); 3241 3241 + std::shared_ptr<Zombie> zomb = dynamic_pointer_cast<Zombie>(hitResult->entity); 3242 3242 std::shared_ptr<ItemInstance> heldItem=nullptr; 3243 3243 3244 3244 if(player->inventory->IsHeldItem()) ··· 3475 3475 3476 3476 if((player->ullButtonsPressed&(1LL<<MINECRAFT_ACTION_SPAWN_CREEPER)) && app.GetMobsDontAttackEnabled()) 3477 3477 { 3478 3478 - //std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(Creeper::_class->newInstance( level )); 3479 3479 - //std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 3480 3480 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(std::shared_ptr<Spider>(new Spider( level ))); 3478 3478 + //std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(Creeper::_class->newInstance( level )); 3479 3479 + //std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 3480 3480 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(std::shared_ptr<Spider>(new Spider( level ))); 3481 3481 mob->moveTo(player->x+1, player->y, player->z+1, level->random->nextFloat() * 360, 0); 3482 3482 level->addEntity(mob); 3483 3483 } ··· 3507 3507 3508 3508 if((player->ullButtonsPressed&(1LL<<MINECRAFT_ACTION_INVENTORY)) && gameMode->isInputAllowed(MINECRAFT_ACTION_INVENTORY)) 3509 3509 { 3510 3510 - std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player ); 3510 3510 + std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player ); 3511 3511 ui.PlayUISFX(eSFX_Press); 3512 3512 app.LoadInventoryMenu(iPad,player); 3513 3513 } 3514 3514 3515 3515 if((player->ullButtonsPressed&(1LL<<MINECRAFT_ACTION_CRAFTING)) && gameMode->isInputAllowed(MINECRAFT_ACTION_CRAFTING)) 3516 3516 { 3517 3517 - std::shared_ptr<LocalPlayer> player = std::dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player ); 3517 3517 + std::shared_ptr<LocalPlayer> player = dynamic_pointer_cast<LocalPlayer>( Minecraft::GetInstance()->player ); 3518 3518 3519 3519 // 4J-PB - reordered the if statement so creative mode doesn't bring up the crafting table 3520 3520 // 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 ··· 4697 4697 4698 4698 if(button==1 && (player->isSleeping() && level != NULL && level->isClientSide)) 4699 4699 { 4700 4700 - std::shared_ptr<MultiplayerLocalPlayer> mplp = std::dynamic_pointer_cast<MultiplayerLocalPlayer>( player ); 4700 4700 + std::shared_ptr<MultiplayerLocalPlayer> mplp = dynamic_pointer_cast<MultiplayerLocalPlayer>( player ); 4701 4701 4702 4702 if(mplp) mplp->StopSleeping(); 4703 4703

+1 -1

Minecraft.Client/MinecraftServer.cpp

··· 1278 1278 { 1279 1279 std::shared_ptr<ServerPlayer> player = players->players.at(0); 1280 1280 eINSTANCEOF factory = (eINSTANCEOF)((size_t)param); 1281 1281 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(factory,player->level )); 1281 1281 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(factory,player->level )); 1282 1282 mob->moveTo(player->x+1, player->y, player->z+1, player->level->random->nextFloat() * 360, 0); 1283 1283 mob->setDespawnProtected(); // 4J added, default to being protected against despawning (has to be done after initial position is set) 1284 1284 player->level->addEntity(mob);

+5 -5

Minecraft.Client/MobRenderer.cpp

··· 35 35 { 36 36 // 4J - added - this used to use generics so the input parameter could be a mob (or derived type), but we aren't 37 37 // able to do that so dynamically casting to get the more specific type here. 38 38 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(_mob); 38 38 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(_mob); 39 39 glPushMatrix(); 40 40 glDisable(GL_CULL_FACE); 41 41 ··· 52 52 float bodyRot = rotlerp(mob->yBodyRotO, mob->yBodyRot, a); 53 53 float headRot = rotlerp(mob->yHeadRotO, mob->yHeadRot, a); 54 54 55 55 - if (mob->isRiding() && std::dynamic_pointer_cast<Mob>(mob->riding)) 55 55 + if (mob->isRiding() && dynamic_pointer_cast<Mob>(mob->riding)) 56 56 { 57 57 - std::shared_ptr<Mob> riding = std::dynamic_pointer_cast<Mob>(mob->riding); 57 57 + std::shared_ptr<Mob> riding = dynamic_pointer_cast<Mob>(mob->riding); 58 58 bodyRot = rotlerp(riding->yBodyRotO, riding->yBodyRot, a); 59 59 60 60 float headDiff = Mth::wrapDegrees(headRot - bodyRot); ··· 235 235 236 236 void MobRenderer::renderModel(std::shared_ptr<Entity> mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale) 237 237 { 238 238 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player); 238 238 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player); 239 239 240 240 bindTexture(mob->customTextureUrl, mob->getTexture()); 241 241 if (!mob->isInvisible()) ··· 396 396 Tesselator *t = Tesselator::getInstance(); 397 397 398 398 int offs = 0; 399 399 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mob); 399 399 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob); 400 400 if (player != NULL && app.isXuidDeadmau5( player->getXuid() ) ) offs = -10; 401 401 402 402 wstring playerName;

+1 -1

Minecraft.Client/MobSpawnerRenderer.cpp

··· 8 8 void MobSpawnerRenderer::render(std::shared_ptr<TileEntity> _spawner, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled) 9 9 { 10 10 // 4J - dynamic cast required because we aren't using templates/generics in our version 11 11 - std::shared_ptr<MobSpawnerTileEntity> spawner = std::dynamic_pointer_cast<MobSpawnerTileEntity>(_spawner); 11 11 + std::shared_ptr<MobSpawnerTileEntity> spawner = dynamic_pointer_cast<MobSpawnerTileEntity>(_spawner); 12 12 13 13 glPushMatrix(); 14 14 glTranslatef((float) x + 0.5f, (float) y, (float) z + 0.5f);

+2 -2

Minecraft.Client/MultiPlayerLocalPlayer.cpp

··· 334 334 } 335 335 else if (!wasRiding && isRiding) 336 336 { 337 337 - if(std::dynamic_pointer_cast<Minecart>(e) != NULL) 337 337 + if(dynamic_pointer_cast<Minecart>(e) != NULL) 338 338 gameMode->getTutorial()->changeTutorialState(e_Tutorial_State_Riding_Minecart); 339 339 - else if(std::dynamic_pointer_cast<Boat>(e) != NULL) 339 339 + else if(dynamic_pointer_cast<Boat>(e) != NULL) 340 340 gameMode->getTutorial()->changeTutorialState(e_Tutorial_State_Riding_Boat); 341 341 } 342 342 }

+2 -2

Minecraft.Client/MushroomCowRenderer.cpp

··· 13 13 { 14 14 // 4J - original version used generics and thus had an input parameter of type MushroomCow rather than std::shared_ptr<Entity> we have here - 15 15 // do some casting around instead 16 16 - //std::shared_ptr<MushroomCow> mob = std::dynamic_pointer_cast<MushroomCow>(_mob); 16 16 + //std::shared_ptr<MushroomCow> mob = dynamic_pointer_cast<MushroomCow>(_mob); 17 17 18 18 // 4J Stu - No need to do the cast, just pass through as-is 19 19 MobRenderer::render(_mob, x, y, z, rot, a); ··· 23 23 { 24 24 // 4J - original version used generics and thus had an input parameter of type MushroomCow rather than std::shared_ptr<Mob> we have here - 25 25 // do some casting around instead 26 26 - std::shared_ptr<MushroomCow> mob = std::dynamic_pointer_cast<MushroomCow>(_mob); 26 26 + std::shared_ptr<MushroomCow> mob = dynamic_pointer_cast<MushroomCow>(_mob); 27 27 MobRenderer::additionalRendering(mob, a); 28 28 if (mob->isBaby()) return; 29 29 bindTexture(TN_TERRAIN); // 4J was "/terrain.png"

+1 -1

Minecraft.Client/OzelotModel.cpp

··· 182 182 183 183 void OzelotModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r, float a) 184 184 { 185 185 - std::shared_ptr<Ozelot> ozelot = std::dynamic_pointer_cast<Ozelot>(mob); 185 185 + std::shared_ptr<Ozelot> ozelot = dynamic_pointer_cast<Ozelot>(mob); 186 186 187 187 body->y = bodyWalkY; 188 188 body->z = bodyWalkZ;

+1 -1

Minecraft.Client/OzelotRenderer.cpp

··· 15 15 { 16 16 // 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity> we have here - 17 17 // do some casting around instead 18 18 - std::shared_ptr<Ozelot> mob = std::dynamic_pointer_cast<Ozelot>(_mob); 18 18 + std::shared_ptr<Ozelot> mob = dynamic_pointer_cast<Ozelot>(_mob); 19 19 MobRenderer::scale(mob, a); 20 20 if (mob->isTame()) 21 21 {

+1 -1

Minecraft.Client/PS3/PS3Extras/Ps3Types.h

··· 22 22 23 23 using std::tr1::bad_weak_ptr; 24 24 using std::tr1::const_pointer_cast; 25 25 - using std::tr1::std::dynamic_pointer_cast; 25 25 + using std::tr1::dynamic_pointer_cast; 26 26 using std::tr1::enable_shared_from_this; 27 27 using std::tr1::get_deleter; 28 28 using std::tr1::std::shared_ptr;

+1 -1

Minecraft.Client/PaintingRenderer.cpp

··· 14 14 void PaintingRenderer::render(std::shared_ptr<Entity> _painting, double x, double y, double z, float rot, float a) 15 15 { 16 16 // 4J - dynamic cast required because we aren't using templates/generics in our version 17 17 - std::shared_ptr<Painting> painting = std::dynamic_pointer_cast<Painting>(_painting); 17 17 + std::shared_ptr<Painting> painting = dynamic_pointer_cast<Painting>(_painting); 18 18 19 19 random->setSeed(187); 20 20

+2 -2

Minecraft.Client/Particle.cpp

··· 66 66 xd *= power; 67 67 yd = (yd - 0.1f) * power + 0.1f; 68 68 zd *= power; 69 69 - return std::dynamic_pointer_cast<Particle>( shared_from_this() ); 69 69 + return dynamic_pointer_cast<Particle>( shared_from_this() ); 70 70 } 71 71 72 72 std::shared_ptr<Particle> Particle::scale(float scale) 73 73 { 74 74 setSize(0.2f * scale, 0.2f * scale); 75 75 size *= scale; 76 76 - return std::dynamic_pointer_cast<Particle>( shared_from_this() ); 76 76 + return dynamic_pointer_cast<Particle>( shared_from_this() ); 77 77 } 78 78 79 79 void Particle::setColor(float r, float g, float b)

+1 -1

Minecraft.Client/PigRenderer.cpp

··· 10 10 int PigRenderer::prepareArmor(std::shared_ptr<Mob> _pig, int layer, float a) 11 11 { 12 12 // 4J - dynamic cast required because we aren't using templates/generics in our version 13 13 - std::shared_ptr<Pig> pig = std::dynamic_pointer_cast<Pig>(_pig); 13 13 + std::shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(_pig); 14 14 15 15 MemSect(31); 16 16 bindTexture(TN_MOB_SADDLE); // 4J was L"/mob/saddle.png"

+1 -1

Minecraft.Client/PistonPieceRenderer.cpp

··· 15 15 void PistonPieceRenderer::render(std::shared_ptr<TileEntity> _entity, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled) 16 16 { 17 17 // 4J - dynamic cast required because we aren't using templates/generics in our version 18 18 - std::shared_ptr<PistonPieceEntity> entity = std::dynamic_pointer_cast<PistonPieceEntity>(_entity); 18 18 + std::shared_ptr<PistonPieceEntity> entity = dynamic_pointer_cast<PistonPieceEntity>(_entity); 19 19 20 20 Tile *tile = Tile::tiles[entity->getId()]; 21 21 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

+7 -7

Minecraft.Client/PlayerConnection.cpp

··· 1273 1273 { 1274 1274 std::shared_ptr<TileEntity> te = level->getTileEntity(packet->x, packet->y, packet->z); 1275 1275 1276 1276 - if (std::dynamic_pointer_cast<SignTileEntity>(te) != NULL) 1276 1276 + if (dynamic_pointer_cast<SignTileEntity>(te) != NULL) 1277 1277 { 1278 1278 - std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>(te); 1278 1278 + std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>(te); 1279 1279 if (!ste->isEditable()) 1280 1280 { 1281 1281 server->warn(L"Player " + player->name + L" just tried to change non-editable sign"); ··· 1284 1284 } 1285 1285 1286 1286 // 4J-JEV: Changed to allow characters to display as a []. 1287 1287 - if (std::dynamic_pointer_cast<SignTileEntity>(te) != NULL) 1287 1287 + if (dynamic_pointer_cast<SignTileEntity>(te) != NULL) 1288 1288 { 1289 1289 int x = packet->x; 1290 1290 int y = packet->y; 1291 1291 int z = packet->z; 1292 1292 - std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>(te); 1292 1292 + std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>(te); 1293 1293 for (int i = 0; i < 4; i++) 1294 1294 { 1295 1295 wstring lineText = packet->lines[i].substr(0,15); ··· 1512 1512 1513 1513 void PlayerConnection::handleDebugOptions(std::shared_ptr<DebugOptionsPacket> packet) 1514 1514 { 1515 1515 - //Player player = std::dynamic_pointer_cast<Player>( player->shared_from_this() ); 1515 1515 + //Player player = dynamic_pointer_cast<Player>( player->shared_from_this() ); 1516 1516 player->SetDebugOptions(packet->m_uiVal); 1517 1517 } 1518 1518 ··· 1528 1528 1529 1529 if(app.DebugSettingsOn() && (player->GetDebugOptions()&(1L<<eDebugSetting_CraftAnything))) 1530 1530 { 1531 1531 - pTempItemInst->onCraftedBy(player->level, std::dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count ); 1531 1531 + pTempItemInst->onCraftedBy(player->level, dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count ); 1532 1532 if(player->inventory->add(pTempItemInst)==false ) 1533 1533 { 1534 1534 // no room in inventory, so throw it down ··· 1542 1542 // TODO 4J Stu - Assume at the moment that the client can work this out for us... 1543 1543 //if(pRecipeIngredientsRequired[iRecipe].bCanMake) 1544 1544 //{ 1545 1545 - pTempItemInst->onCraftedBy(player->level, std::dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count ); 1545 1545 + pTempItemInst->onCraftedBy(player->level, dynamic_pointer_cast<Player>( player->shared_from_this() ), pTempItemInst->count ); 1546 1546 1547 1547 // and remove those resources from your inventory 1548 1548 for(int i=0;i<pRecipeIngredientsRequired[iRecipe].iIngC;i++)

+2 -2

Minecraft.Client/PlayerList.cpp

··· 1037 1037 vector< std::shared_ptr<ServerPlayer> > sentTo; 1038 1038 if( except != NULL ) 1039 1039 { 1040 1040 - sentTo.push_back(std::dynamic_pointer_cast<ServerPlayer>(except)); 1040 1040 + sentTo.push_back(dynamic_pointer_cast<ServerPlayer>(except)); 1041 1041 } 1042 1042 1043 1043 for (unsigned int i = 0; i < players.size(); i++) ··· 1080 1080 if (xd * xd + yd * yd + zd * zd < range * range) 1081 1081 { 1082 1082 #if 0 // _DEBUG 1083 1083 - std::shared_ptr<LevelSoundPacket> SoundPacket= std::dynamic_pointer_cast<LevelSoundPacket>(packet); 1083 1083 + std::shared_ptr<LevelSoundPacket> SoundPacket= dynamic_pointer_cast<LevelSoundPacket>(packet); 1084 1084 1085 1085 if(SoundPacket) 1086 1086 {

+9 -9

Minecraft.Client/PlayerRenderer.cpp

··· 49 49 int PlayerRenderer::prepareArmor(std::shared_ptr<Mob> _player, int layer, float a) 50 50 { 51 51 // 4J - dynamic cast required because we aren't using templates/generics in our version 52 52 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(_player); 52 52 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player); 53 53 54 54 // 4J-PB - need to disable rendering armour for some special skins (Daleks) 55 55 unsigned int uiAnimOverrideBitmask=player->getAnimOverrideBitmask(); ··· 111 111 void PlayerRenderer::prepareSecondPassArmor(std::shared_ptr<Mob> _player, int layer, float a) 112 112 { 113 113 // 4J - dynamic cast required because we aren't using templates/generics in our version 114 114 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(_player); 114 114 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player); 115 115 std::shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer); 116 116 if (itemInstance != NULL) 117 117 { ··· 130 130 void PlayerRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a) 131 131 { 132 132 // 4J - dynamic cast required because we aren't using templates/generics in our version 133 133 - std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob); 133 133 + std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob); 134 134 135 135 if(mob->hasInvisiblePrivilege()) return; 136 136 ··· 169 169 armorParts1->sneaking = armorParts2->sneaking = humanoidModel->sneaking = mob->isSneaking(); 170 170 171 171 double yp = y - mob->heightOffset; 172 172 - if (mob->isSneaking() && (std::dynamic_pointer_cast<LocalPlayer>(mob) == NULL)) 172 172 + if (mob->isSneaking() && (dynamic_pointer_cast<LocalPlayer>(mob) == NULL)) 173 173 { 174 174 yp -= 2 / 16.0f; 175 175 } ··· 231 231 void PlayerRenderer::renderName(std::shared_ptr<Mob> _mob, double x, double y, double z) 232 232 { 233 233 // 4J - dynamic cast required because we aren't using templates/generics in our version 234 234 - std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob); 234 234 + std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob); 235 235 236 236 if (Minecraft::renderNames() && mob != entityRenderDispatcher->cameraEntity 237 237 && !mob->isInvisibleTo(Minecraft::GetInstance()->player) ) // 4J-JEV: Todo, move to LivingEntityRenderer. ··· 321 321 MobRenderer::additionalRendering(_mob,a); 322 322 323 323 // 4J - dynamic cast required because we aren't using templates/generics in our version 324 324 - std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob); 324 324 + std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob); 325 325 326 326 std::shared_ptr<ItemInstance> headGear = mob->inventory->getArmor(3); 327 327 if (headGear != NULL) ··· 543 543 void PlayerRenderer::setupPosition(std::shared_ptr<Mob> _mob, double x, double y, double z) 544 544 { 545 545 // 4J - dynamic cast required because we aren't using templates/generics in our version 546 546 - std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob); 546 546 + std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob); 547 547 548 548 if (mob->isAlive() && mob->isSleeping()) 549 549 { ··· 559 559 void PlayerRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a) 560 560 { 561 561 // 4J - dynamic cast required because we aren't using templates/generics in our version 562 562 - std::shared_ptr<Player> mob = std::dynamic_pointer_cast<Player>(_mob); 562 562 + std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob); 563 563 564 564 if (mob->isAlive() && mob->isSleeping()) 565 565 { ··· 578 578 { 579 579 if(app.GetGameHostOption(eGameHostOption_HostCanBeInvisible) > 0) 580 580 { 581 581 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e); 581 581 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e); 582 582 if(player != NULL && player->hasInvisiblePrivilege()) return; 583 583 } 584 584 EntityRenderer::renderShadow(e,x,y,z,pow,a);

+20 -20

Minecraft.Client/ServerLevel.cpp

··· 671 671 { 672 672 e->remove(); 673 673 } 674 674 - if (!server->isNpcsEnabled() && (std::dynamic_pointer_cast<Npc>(e) != NULL)) 674 674 + if (!server->isNpcsEnabled() && (dynamic_pointer_cast<Npc>(e) != NULL)) 675 675 { 676 676 e->remove(); 677 677 } 678 678 - if (e->rider.lock() == NULL || (std::dynamic_pointer_cast<Player>(e->rider.lock())==NULL) ) // 4J - was !(e->rider instanceof Player) 678 678 + if (e->rider.lock() == NULL || (dynamic_pointer_cast<Player>(e->rider.lock())==NULL) ) // 4J - was !(e->rider instanceof Player) 679 679 { 680 680 Level::tick(e, actual); 681 681 } ··· 814 814 815 815 if( getTile( x, y, z ) == Tile::chest_Id ) 816 816 { 817 817 - std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(getTileEntity(x, y, z)); 817 817 + std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(getTileEntity(x, y, z)); 818 818 if (chest != NULL) 819 819 { 820 820 if( chest->isBonusChest ) ··· 1019 1019 vector<std::shared_ptr<ServerPlayer> > sentTo; 1020 1020 for(AUTO_VAR(it, players.begin()); it != players.end(); ++it) 1021 1021 { 1022 1022 - std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(*it); 1022 1022 + std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(*it); 1023 1023 if (player->dimension != dimension->id) continue; 1024 1024 1025 1025 bool knockbackOnly = false; ··· 1188 1188 bool ServerLevel::addEntity(std::shared_ptr<Entity> e) 1189 1189 { 1190 1190 // If its an item entity, and we've got to our capacity, delete the oldest 1191 1191 - if( std::dynamic_pointer_cast<ItemEntity>(e) != NULL ) 1191 1191 + if( dynamic_pointer_cast<ItemEntity>(e) != NULL ) 1192 1192 { 1193 1193 // printf("Adding item entity count %d\n",m_itemEntities.size()); 1194 1194 EnterCriticalSection(&m_limiterCS); ··· 1200 1200 LeaveCriticalSection(&m_limiterCS); 1201 1201 } 1202 1202 // If its an hanging entity, and we've got to our capacity, delete the oldest 1203 1203 - else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL ) 1203 1203 + else if( dynamic_pointer_cast<HangingEntity>(e) != NULL ) 1204 1204 { 1205 1205 // printf("Adding item entity count %d\n",m_itemEntities.size()); 1206 1206 EnterCriticalSection(&m_limiterCS); ··· 1217 1217 LeaveCriticalSection(&m_limiterCS); 1218 1218 } 1219 1219 // If its an arrow entity, and we've got to our capacity, delete the oldest 1220 1220 - else if( std::dynamic_pointer_cast<Arrow>(e) != NULL ) 1220 1220 + else if( dynamic_pointer_cast<Arrow>(e) != NULL ) 1221 1221 { 1222 1222 // printf("Adding arrow entity count %d\n",m_arrowEntities.size()); 1223 1223 EnterCriticalSection(&m_limiterCS); ··· 1229 1229 LeaveCriticalSection(&m_limiterCS); 1230 1230 } 1231 1231 // If its an experience orb entity, and we've got to our capacity, delete the oldest 1232 1232 - else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL ) 1232 1232 + else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL ) 1233 1233 { 1234 1234 // printf("Adding arrow entity count %d\n",m_arrowEntities.size()); 1235 1235 EnterCriticalSection(&m_limiterCS); ··· 1246 1246 // Maintain a cound of primed tnt & falling tiles in this level 1247 1247 void ServerLevel::entityAddedExtra(std::shared_ptr<Entity> e) 1248 1248 { 1249 1249 - if( std::dynamic_pointer_cast<ItemEntity>(e) != NULL ) 1249 1249 + if( dynamic_pointer_cast<ItemEntity>(e) != NULL ) 1250 1250 { 1251 1251 EnterCriticalSection(&m_limiterCS); 1252 1252 m_itemEntities.push_back(e); 1253 1253 // printf("entity added: item entity count now %d\n",m_itemEntities.size()); 1254 1254 LeaveCriticalSection(&m_limiterCS); 1255 1255 } 1256 1256 - else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL ) 1256 1256 + else if( dynamic_pointer_cast<HangingEntity>(e) != NULL ) 1257 1257 { 1258 1258 EnterCriticalSection(&m_limiterCS); 1259 1259 m_hangingEntities.push_back(e); 1260 1260 // printf("entity added: item entity count now %d\n",m_itemEntities.size()); 1261 1261 LeaveCriticalSection(&m_limiterCS); 1262 1262 } 1263 1263 - else if( std::dynamic_pointer_cast<Arrow>(e) != NULL ) 1263 1263 + else if( dynamic_pointer_cast<Arrow>(e) != NULL ) 1264 1264 { 1265 1265 EnterCriticalSection(&m_limiterCS); 1266 1266 m_arrowEntities.push_back(e); 1267 1267 // printf("entity added: arrow entity count now %d\n",m_arrowEntities.size()); 1268 1268 LeaveCriticalSection(&m_limiterCS); 1269 1269 } 1270 1270 - else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL ) 1270 1270 + else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL ) 1271 1271 { 1272 1272 EnterCriticalSection(&m_limiterCS); 1273 1273 m_experienceOrbEntities.push_back(e); 1274 1274 // printf("entity added: experience orb entity count now %d\n",m_arrowEntities.size()); 1275 1275 LeaveCriticalSection(&m_limiterCS); 1276 1276 } 1277 1277 - else if( std::dynamic_pointer_cast<PrimedTnt>(e) != NULL ) 1277 1277 + else if( dynamic_pointer_cast<PrimedTnt>(e) != NULL ) 1278 1278 { 1279 1279 EnterCriticalSection(&m_limiterCS); 1280 1280 m_primedTntCount++; 1281 1281 LeaveCriticalSection(&m_limiterCS); 1282 1282 } 1283 1283 - else if( std::dynamic_pointer_cast<FallingTile>(e) != NULL ) 1283 1283 + else if( dynamic_pointer_cast<FallingTile>(e) != NULL ) 1284 1284 { 1285 1285 EnterCriticalSection(&m_limiterCS); 1286 1286 m_fallingTileCount++; ··· 1291 1291 // Maintain a cound of primed tnt & falling tiles in this level, and remove any item entities from our list 1292 1292 void ServerLevel::entityRemovedExtra(std::shared_ptr<Entity> e) 1293 1293 { 1294 1294 - if( std::dynamic_pointer_cast<ItemEntity>(e) != NULL ) 1294 1294 + if( dynamic_pointer_cast<ItemEntity>(e) != NULL ) 1295 1295 { 1296 1296 EnterCriticalSection(&m_limiterCS); 1297 1297 // printf("entity removed: item entity count %d\n",m_itemEntities.size()); ··· 1304 1304 // printf("entity removed: item entity count now %d\n",m_itemEntities.size()); 1305 1305 LeaveCriticalSection(&m_limiterCS); 1306 1306 } 1307 1307 - else if( std::dynamic_pointer_cast<HangingEntity>(e) != NULL ) 1307 1307 + else if( dynamic_pointer_cast<HangingEntity>(e) != NULL ) 1308 1308 { 1309 1309 EnterCriticalSection(&m_limiterCS); 1310 1310 // printf("entity removed: item entity count %d\n",m_itemEntities.size()); ··· 1317 1317 // printf("entity removed: item entity count now %d\n",m_itemEntities.size()); 1318 1318 LeaveCriticalSection(&m_limiterCS); 1319 1319 } 1320 1320 - else if( std::dynamic_pointer_cast<Arrow>(e) != NULL ) 1320 1320 + else if( dynamic_pointer_cast<Arrow>(e) != NULL ) 1321 1321 { 1322 1322 EnterCriticalSection(&m_limiterCS); 1323 1323 // printf("entity removed: arrow entity count %d\n",m_arrowEntities.size()); ··· 1330 1330 // printf("entity removed: arrow entity count now %d\n",m_arrowEntities.size()); 1331 1331 LeaveCriticalSection(&m_limiterCS); 1332 1332 } 1333 1333 - else if( std::dynamic_pointer_cast<ExperienceOrb>(e) != NULL ) 1333 1333 + else if( dynamic_pointer_cast<ExperienceOrb>(e) != NULL ) 1334 1334 { 1335 1335 EnterCriticalSection(&m_limiterCS); 1336 1336 // printf("entity removed: experience orb entity count %d\n",m_arrowEntities.size()); ··· 1343 1343 // printf("entity removed: experience orb entity count now %d\n",m_arrowEntities.size()); 1344 1344 LeaveCriticalSection(&m_limiterCS); 1345 1345 } 1346 1346 - else if( std::dynamic_pointer_cast<PrimedTnt>(e) != NULL ) 1346 1346 + else if( dynamic_pointer_cast<PrimedTnt>(e) != NULL ) 1347 1347 { 1348 1348 EnterCriticalSection(&m_limiterCS); 1349 1349 m_primedTntCount--; 1350 1350 LeaveCriticalSection(&m_limiterCS); 1351 1351 } 1352 1352 - else if( std::dynamic_pointer_cast<FallingTile>(e) != NULL ) 1352 1352 + else if( dynamic_pointer_cast<FallingTile>(e) != NULL ) 1353 1353 { 1354 1354 EnterCriticalSection(&m_limiterCS); 1355 1355 m_fallingTileCount--;

+2 -2

Minecraft.Client/ServerLevelListener.cpp

··· 48 48 // 4J added 49 49 void ServerLevelListener::playerRemoved(std::shared_ptr<Entity> entity) 50 50 { 51 51 - std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(entity); 51 51 + std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(entity); 52 52 player->getLevel()->getTracker()->removePlayer(entity); 53 53 } 54 54 ··· 76 76 { 77 77 // 4J-PB - I don't want to broadcast player sounds to my local machine, since we're already playing these in the LevelRenderer::playSound. 78 78 // 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 79 79 - std::shared_ptr<Player> player= std::dynamic_pointer_cast<Player>(entity); 79 79 + std::shared_ptr<Player> player= dynamic_pointer_cast<Player>(entity); 80 80 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))); 81 81 } 82 82 }

+15 -15

Minecraft.Client/ServerPlayer.cpp

··· 293 293 // 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. 294 294 if (Item::items[ie->id]->isComplex() ) // && connection->countDelayedPackets() <= 2) 295 295 { 296 296 - std::shared_ptr<Packet> packet = (dynamic_cast<ComplexItem *>(Item::items[ie->id])->getUpdatePacket(ie, level, std::dynamic_pointer_cast<Player>( shared_from_this() ) ) ); 296 296 + std::shared_ptr<Packet> packet = (dynamic_cast<ComplexItem *>(Item::items[ie->id])->getUpdatePacket(ie, level, dynamic_pointer_cast<Player>( shared_from_this() ) ) ); 297 297 if (packet != NULL) 298 298 { 299 299 connection->send(packet); ··· 474 474 // { 475 475 // if(level->dimension->id == 0 ) 476 476 // { 477 477 - // server->players->toggleDimension( std::dynamic_pointer_cast<ServerPlayer>( shared_from_this() ), 1 ); 477 477 + // server->players->toggleDimension( dynamic_pointer_cast<ServerPlayer>( shared_from_this() ), 1 ); 478 478 // } 479 479 // unsigned int uiVal=app.GetGameSettingsDebugMask(ProfileManager.GetPrimaryPad()); 480 480 // app.SetGameSettingsDebugMask(ProfileManager.GetPrimaryPad(),uiVal&~(1L<<eDebugSetting_GoToEnd)); ··· 519 519 if (dimension == -1) targetDimension = 0; 520 520 else targetDimension = -1; 521 521 522 522 - server->getPlayers()->toggleDimension( std::dynamic_pointer_cast<ServerPlayer>( shared_from_this() ), targetDimension ); 522 522 + server->getPlayers()->toggleDimension( dynamic_pointer_cast<ServerPlayer>( shared_from_this() ), targetDimension ); 523 523 lastSentExp = -1; 524 524 lastSentHealth = -1; 525 525 lastSentFood = -1; ··· 563 563 564 564 void ServerPlayer::die(DamageSource *source) 565 565 { 566 566 - server->getPlayers()->broadcastAll(source->getDeathMessagePacket(std::dynamic_pointer_cast<Player>(shared_from_this()))); 566 566 + server->getPlayers()->broadcastAll(source->getDeathMessagePacket(dynamic_pointer_cast<Player>(shared_from_this()))); 567 567 inventory->dropAll(); 568 568 } 569 569 ··· 578 578 std::shared_ptr<Entity> source = dmgSource->getDirectEntity(); 579 579 580 580 581 581 - if (std::dynamic_pointer_cast<Player>(source) != NULL && (!server->pvp || !std::dynamic_pointer_cast<Player>(source)->isAllowedToAttackPlayers()) ) 581 581 + if (dynamic_pointer_cast<Player>(source) != NULL && (!server->pvp || !dynamic_pointer_cast<Player>(source)->isAllowedToAttackPlayers()) ) 582 582 { 583 583 return false; 584 584 } 585 585 586 586 if (source != NULL && source->GetType() == eTYPE_ARROW) 587 587 { 588 588 - std::shared_ptr<Arrow> arrow = std::dynamic_pointer_cast<Arrow>(source); 589 589 - if (std::dynamic_pointer_cast<Player>(arrow->owner) != NULL && (!server->pvp || !std::dynamic_pointer_cast<Player>(arrow->owner)->isAllowedToAttackPlayers()) ) 588 588 + std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(source); 589 589 + if (dynamic_pointer_cast<Player>(arrow->owner) != NULL && (!server->pvp || !dynamic_pointer_cast<Player>(arrow->owner)->isAllowedToAttackPlayers()) ) 590 590 { 591 591 return false; 592 592 } ··· 645 645 m_lastDamageSource = eTelemetryPlayerDeathSource_Explosion_Tnt; 646 646 break; 647 647 case eTYPE_ARROW: 648 648 - if ((std::dynamic_pointer_cast<Arrow>(source))->owner != NULL) 648 648 + if ((dynamic_pointer_cast<Arrow>(source))->owner != NULL) 649 649 { 650 650 - std::shared_ptr<Entity> attacker = (std::dynamic_pointer_cast<Arrow>(source))->owner; 650 650 + std::shared_ptr<Entity> attacker = (dynamic_pointer_cast<Arrow>(source))->owner; 651 651 if (attacker != NULL) 652 652 { 653 653 switch(attacker->GetType()) ··· 725 725 connection->teleport(pos->x, pos->y, pos->z, 0, 0); 726 726 delete pos; 727 727 } 728 728 - server->getPlayers()->toggleDimension( std::dynamic_pointer_cast<ServerPlayer>(shared_from_this()), 1); 728 728 + server->getPlayers()->toggleDimension( dynamic_pointer_cast<ServerPlayer>(shared_from_this()), 1); 729 729 lastSentExp = -1; 730 730 lastSentHealth = -1; 731 731 lastSentFood = -1; ··· 869 869 { 870 870 nextContainerCounter(); 871 871 connection->send(std::shared_ptr<ContainerOpenPacket> ( new ContainerOpenPacket(containerCounter, ContainerOpenPacket::REPAIR_TABLE, 0, 9)) ); 872 872 - containerMenu = new RepairMenu(inventory, level, x, y, z, std::dynamic_pointer_cast<Player>(shared_from_this())); 872 872 + containerMenu = new RepairMenu(inventory, level, x, y, z, dynamic_pointer_cast<Player>(shared_from_this())); 873 873 containerMenu->containerId = containerCounter; 874 874 containerMenu->addSlotListener(this); 875 875 } ··· 966 966 967 967 connection->send(std::shared_ptr<ContainerOpenPacket>(new ContainerOpenPacket(containerCounter, ContainerOpenPacket::TRADER_NPC, container->getName(), container->getContainerSize()))); 968 968 969 969 - MerchantRecipeList *offers = traderTarget->getOffers(std::dynamic_pointer_cast<Player>(shared_from_this())); 969 969 + MerchantRecipeList *offers = traderTarget->getOffers(dynamic_pointer_cast<Player>(shared_from_this())); 970 970 if (offers != NULL) 971 971 { 972 972 ByteArrayOutputStream rawOutput; ··· 1057 1057 1058 1058 void ServerPlayer::doCloseContainer() 1059 1059 { 1060 1060 - containerMenu->removed( std::dynamic_pointer_cast<Player>( shared_from_this() ) ); 1060 1060 + containerMenu->removed( dynamic_pointer_cast<Player>( shared_from_this() ) ); 1061 1061 containerMenu = inventoryMenu; 1062 1062 } 1063 1063 ··· 1368 1368 lastSentExp = -1; 1369 1369 lastSentHealth = -1; 1370 1370 lastSentFood = -1; 1371 1371 - entitiesToRemove = std::dynamic_pointer_cast<ServerPlayer>(oldPlayer)->entitiesToRemove; 1371 1371 + entitiesToRemove = dynamic_pointer_cast<ServerPlayer>(oldPlayer)->entitiesToRemove; 1372 1372 } 1373 1373 1374 1374 void ServerPlayer::onEffectAdded(MobEffectInstance *effect) ··· 1430 1430 1431 1431 bool ServerPlayer::hasPermission(EGameCommand command) 1432 1432 { 1433 1433 - return server->getPlayers()->isOp(std::dynamic_pointer_cast<ServerPlayer>(shared_from_this())); 1433 1433 + return server->getPlayers()->isOp(dynamic_pointer_cast<ServerPlayer>(shared_from_this())); 1434 1434 } 1435 1435 1436 1436 // 4J - Don't use

+1 -1

Minecraft.Client/ServerPlayerGameMode.cpp

··· 247 247 if( isCreative() ) 248 248 { 249 249 clientToUpdateRenderer = true; 250 250 - if( std::dynamic_pointer_cast<ServerPlayer>(player)->connection->isLocal() ) 250 250 + if( dynamic_pointer_cast<ServerPlayer>(player)->connection->isLocal() ) 251 251 { 252 252 // Establish whether we are sharing this chunk between client & server 253 253 MultiPlayerLevel *clientLevel = Minecraft::GetInstance()->getLevel(level->dimension->id);

+1 -1

Minecraft.Client/SheepFurModel.cpp

··· 45 45 { 46 46 QuadrupedModel::prepareMobModel(mob, time, r, a); 47 47 48 48 - std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(mob); 48 48 + std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(mob); 49 49 head->y = 6 + sheep->getHeadEatPositionScale(a) * 9.0f; 50 50 headXRot = sheep->getHeadEatAngleScale(a); 51 51 }

+1 -1

Minecraft.Client/SheepModel.cpp

··· 24 24 { 25 25 QuadrupedModel::prepareMobModel(mob, time, r, a); 26 26 27 27 - std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(mob); 27 27 + std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(mob); 28 28 head->y = 6 + sheep->getHeadEatPositionScale(a) * 9.0f; 29 29 headXRot = sheep->getHeadEatAngleScale(a); 30 30 }

+1 -1

Minecraft.Client/SheepRenderer.cpp

··· 11 11 int SheepRenderer::prepareArmor(std::shared_ptr<Mob> _sheep, int layer, float a) 12 12 { 13 13 // 4J - dynamic cast required because we aren't using templates/generics in our version 14 14 - std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(_sheep); 14 14 + std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(_sheep); 15 15 16 16 if (layer == 0 && !sheep->isSheared() && 17 17 !sheep->isInvisibleTo(Minecraft::GetInstance()->player)) // 4J-JEV: Todo, merge with java fix (for invisible sheep armour) in '1.7.5'.

+1 -1

Minecraft.Client/SignRenderer.cpp

··· 16 16 void SignRenderer::render(std::shared_ptr<TileEntity> _sign, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled) 17 17 { 18 18 // 4J - dynamic cast required because we aren't using templates/generics in our version 19 19 - std::shared_ptr<SignTileEntity> sign = std::dynamic_pointer_cast<SignTileEntity>(_sign); 19 19 + std::shared_ptr<SignTileEntity> sign = dynamic_pointer_cast<SignTileEntity>(_sign); 20 20 21 21 Tile *tile = sign->getTile(); 22 22

+1 -1

Minecraft.Client/SkullTileRenderer.cpp

··· 21 21 22 22 void SkullTileRenderer::render(std::shared_ptr<TileEntity> _skull, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled) 23 23 { 24 24 - std::shared_ptr<SkullTileEntity> skull = std::dynamic_pointer_cast<SkullTileEntity>(_skull); 24 24 + std::shared_ptr<SkullTileEntity> skull = dynamic_pointer_cast<SkullTileEntity>(_skull); 25 25 renderSkull((float) x, (float) y, (float) z, skull->getData() & SkullTile::PLACEMENT_MASK, skull->getRotation() * 360 / 16.0f, skull->getSkullType(), skull->getExtraType()); 26 26 } 27 27

+2 -2

Minecraft.Client/SlimeRenderer.cpp

··· 10 10 int SlimeRenderer::prepareArmor(std::shared_ptr<Mob> _slime, int layer, float a) 11 11 { 12 12 // 4J - dynamic cast required because we aren't using templates/generics in our version 13 13 - std::shared_ptr<Slime> slime = std::dynamic_pointer_cast<Slime>(_slime); 13 13 + std::shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(_slime); 14 14 15 15 if (slime->isInvisible()) return 0; 16 16 ··· 35 35 void SlimeRenderer::scale(std::shared_ptr<Mob> _slime, float a) 36 36 { 37 37 // 4J - dynamic cast required because we aren't using templates/generics in our version 38 38 - std::shared_ptr<Slime> slime = std::dynamic_pointer_cast<Slime>(_slime); 38 38 + std::shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(_slime); 39 39 40 40 float size = (float) slime->getSize(); 41 41 float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1);

+1 -1

Minecraft.Client/SnowManRenderer.cpp

··· 17 17 { 18 18 // 4J - original version used generics and thus had an input parameter of type SnowMan rather than std::shared_ptr<Mob> we have here - 19 19 // do some casting around instead 20 20 - std::shared_ptr<SnowMan> mob = std::dynamic_pointer_cast<SnowMan>(_mob); 20 20 + std::shared_ptr<SnowMan> mob = dynamic_pointer_cast<SnowMan>(_mob); 21 21 22 22 MobRenderer::additionalRendering(mob, a); 23 23 std::shared_ptr<ItemInstance> headGear = std::shared_ptr<ItemInstance>( new ItemInstance(Tile::pumpkin, 1) );

+2 -2

Minecraft.Client/SpiderRenderer.cpp

··· 16 16 int SpiderRenderer::prepareArmor(std::shared_ptr<Mob> _spider, int layer, float a) 17 17 { 18 18 // 4J - dynamic cast required because we aren't using templates/generics in our version 19 19 - std::shared_ptr<Spider> spider = std::dynamic_pointer_cast<Spider>(_spider); 19 19 + std::shared_ptr<Spider> spider = dynamic_pointer_cast<Spider>(_spider); 20 20 21 21 if (layer!=0) return -1; 22 22 MemSect(31); ··· 55 55 void SpiderRenderer::scale(std::shared_ptr<Mob> _mob, float a) 56 56 { 57 57 // 4J - dynamic cast required because we aren't using templates/generics in our version 58 58 - std::shared_ptr<Spider> mob = std::dynamic_pointer_cast<Spider>(_mob); 58 58 + std::shared_ptr<Spider> mob = dynamic_pointer_cast<Spider>(_mob); 59 59 float scale = mob->getModelScale(); 60 60 glScalef(scale, scale, scale); 61 61 }

+2 -2

Minecraft.Client/SquidRenderer.cpp

··· 14 14 void SquidRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a) 15 15 { 16 16 // 4J - dynamic cast required because we aren't using templates/generics in our version 17 17 - std::shared_ptr<Squid> mob = std::dynamic_pointer_cast<Squid>(_mob); 17 17 + std::shared_ptr<Squid> mob = dynamic_pointer_cast<Squid>(_mob); 18 18 19 19 float bodyXRot = (mob->xBodyRotO + (mob->xBodyRot - mob->xBodyRotO) * a); 20 20 float bodyZRot = (mob->zBodyRotO + (mob->zBodyRot - mob->zBodyRotO) * a); ··· 29 29 float SquidRenderer::getBob(std::shared_ptr<Mob> _mob, float a) 30 30 { 31 31 // 4J - dynamic cast required because we aren't using templates/generics in our version 32 32 - std::shared_ptr<Squid> mob = std::dynamic_pointer_cast<Squid>(_mob); 32 32 + std::shared_ptr<Squid> mob = dynamic_pointer_cast<Squid>(_mob); 33 33 34 34 return mob->oldTentacleAngle + (mob->tentacleAngle - mob->oldTentacleAngle) * a; 35 35 }

+4 -4

Minecraft.Client/TerrainParticle.cpp

··· 16 16 17 17 std::shared_ptr<TerrainParticle> TerrainParticle::init(int x, int y, int z, int data) // 4J - added data parameter 18 18 { 19 19 - if (tile == Tile::grass) return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() ); 19 19 + if (tile == Tile::grass) return dynamic_pointer_cast<TerrainParticle>( shared_from_this() ); 20 20 int col = tile->getColor(level, x, y, z, data); // 4J - added data parameter 21 21 rCol *= ((col >> 16) & 0xff) / 255.0f; 22 22 gCol *= ((col >> 8) & 0xff) / 255.0f; 23 23 bCol *= ((col) & 0xff) / 255.0f; 24 24 - return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() ); 24 24 + return dynamic_pointer_cast<TerrainParticle>( shared_from_this() ); 25 25 } 26 26 27 27 std::shared_ptr<TerrainParticle> TerrainParticle::init(int data) 28 28 { 29 29 - if (tile == Tile::grass) return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() ); 29 29 + if (tile == Tile::grass) return dynamic_pointer_cast<TerrainParticle>( shared_from_this() ); 30 30 int col = tile->getColor(data); 31 31 rCol *= ((col >> 16) & 0xff) / 255.0f; 32 32 gCol *= ((col >> 8) & 0xff) / 255.0f; 33 33 bCol *= ((col) & 0xff) / 255.0f; 34 34 - return std::dynamic_pointer_cast<TerrainParticle>( shared_from_this() ); 34 34 + return dynamic_pointer_cast<TerrainParticle>( shared_from_this() ); 35 35 } 36 36 37 37 int TerrainParticle::getParticleTexture()

+1 -1

Minecraft.Client/TheEndPortalRenderer.cpp

··· 10 10 void TheEndPortalRenderer::render(std::shared_ptr<TileEntity> _table, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled) 11 11 { 12 12 // 4J Convert as we aren't using a templated class 13 13 - std::shared_ptr<TheEndPortalTileEntity> table = std::dynamic_pointer_cast<TheEndPortalTileEntity>(_table); 13 13 + std::shared_ptr<TheEndPortalTileEntity> table = dynamic_pointer_cast<TheEndPortalTileEntity>(_table); 14 14 float xx = (float) (tileEntityRenderDispatcher->xPlayer); 15 15 float yy = (float) (tileEntityRenderDispatcher->yPlayer); 16 16 float zz = (float) (tileEntityRenderDispatcher->zPlayer);

+1 -1

Minecraft.Client/TntRenderer.cpp

··· 13 13 void TntRenderer::render(std::shared_ptr<Entity> _tnt, double x, double y, double z, float rot, float a) 14 14 { 15 15 // 4J - dynamic cast required because we aren't using templates/generics in our version 16 16 - std::shared_ptr<PrimedTnt> tnt = std::dynamic_pointer_cast<PrimedTnt>(_tnt); 16 16 + std::shared_ptr<PrimedTnt> tnt = dynamic_pointer_cast<PrimedTnt>(_tnt); 17 17 18 18 glPushMatrix(); 19 19 glTranslatef((float) x, (float) y, (float) z);

+44 -44

Minecraft.Client/TrackedEntity.cpp

··· 68 68 // Moving forward special case for item frames 69 69 if (e->GetType()== eTYPE_ITEM_FRAME && tickCount % 10 == 0) 70 70 { 71 71 - std::shared_ptr<ItemFrame> frame = std::dynamic_pointer_cast<ItemFrame> (e); 71 71 + std::shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame> (e); 72 72 std::shared_ptr<ItemInstance> item = frame->getItem(); 73 73 74 74 if (item != NULL && item->getItem()->id == Item::map_Id && !e->removed) ··· 76 76 std::shared_ptr<MapItemSavedData> data = Item::map->getSavedData(item, e->level); 77 77 for (AUTO_VAR(it,players->begin() ); it != players->end(); ++it) 78 78 { 79 79 - std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(*it); 79 79 + std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(*it); 80 80 data->tickCarriedBy(player, item); 81 81 82 82 if (!player->removed && player->connection && player->connection->countDelayedPackets() <= 5) ··· 276 276 xRotp = xRotn; 277 277 } 278 278 279 279 - // if( std::dynamic_pointer_cast<ServerPlayer>(e) != NULL ) 279 279 + // if( dynamic_pointer_cast<ServerPlayer>(e) != NULL ) 280 280 // { 281 281 // printf("%d: %d + %d = %d (%f)\n",e->entityId,xRotp,xRota,xRotn,e->xRot); 282 282 // } ··· 335 335 { 336 336 dontSend = true; 337 337 // #ifdef _DEBUG 338 338 - // std::shared_ptr<SetEntityMotionPacket> emp= std::dynamic_pointer_cast<SetEntityMotionPacket> (packet); 338 338 + // std::shared_ptr<SetEntityMotionPacket> emp= dynamic_pointer_cast<SetEntityMotionPacket> (packet); 339 339 // if(emp!=NULL) 340 340 // { 341 341 // app.DebugPrintf("Not sending this SetEntityMotionPacket to player - it's already been sent to a player on their console\n"); ··· 370 370 { 371 371 vector< std::shared_ptr<ServerPlayer> > sentTo; 372 372 broadcast(packet); 373 373 - std::shared_ptr<ServerPlayer> sp = std::dynamic_pointer_cast<ServerPlayer>(e); 373 373 + std::shared_ptr<ServerPlayer> sp = dynamic_pointer_cast<ServerPlayer>(e); 374 374 if (sp != NULL && sp->connection) 375 375 { 376 376 sp->connection->send(packet); ··· 478 478 yap = e->yd; 479 479 zap = e->zd; 480 480 481 481 - std::shared_ptr<Player> plr = std::dynamic_pointer_cast<Player>(e); 481 481 + std::shared_ptr<Player> plr = dynamic_pointer_cast<Player>(e); 482 482 if (plr != NULL) 483 483 { 484 484 app.DebugPrintf( "TrackedEntity:: Player '%ls' is now visible to player '%ls', %s.\n", ··· 488 488 } 489 489 490 490 // 4J Stu brought forward to fix when Item Frames 491 491 - if (!e->getEntityData()->isEmpty() && !(std::dynamic_pointer_cast<AddMobPacket>(packet))) 491 491 + if (!e->getEntityData()->isEmpty() && !(dynamic_pointer_cast<AddMobPacket>(packet))) 492 492 { 493 493 sp->connection->send(std::shared_ptr<SetEntityDataPacket>( new SetEntityDataPacket(e->entityId, e->getEntityData(), true))); 494 494 } ··· 512 512 } 513 513 } 514 514 515 515 - if (std::dynamic_pointer_cast<Player>(e) != NULL) 515 515 + if (dynamic_pointer_cast<Player>(e) != NULL) 516 516 { 517 517 - std::shared_ptr<Player> spe = std::dynamic_pointer_cast<Player>(e); 517 517 + std::shared_ptr<Player> spe = dynamic_pointer_cast<Player>(e); 518 518 if (spe->isSleeping()) 519 519 { 520 520 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)) ) ); 521 521 } 522 522 } 523 523 524 524 - if (std::dynamic_pointer_cast<Mob>(e) != NULL) 524 524 + if (dynamic_pointer_cast<Mob>(e) != NULL) 525 525 { 526 526 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(e); 526 526 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e); 527 527 vector<MobEffectInstance *> *activeEffects = mob->getActiveEffects(); 528 528 for(AUTO_VAR(it, activeEffects->begin()); it != activeEffects->end(); ++it) 529 529 { ··· 560 560 { 561 561 for (unsigned int i = 0; i < players->size(); i++) 562 562 { 563 563 - updatePlayer(tracker, std::dynamic_pointer_cast<ServerPlayer>( players->at(i) ) ); 563 563 + updatePlayer(tracker, dynamic_pointer_cast<ServerPlayer>( players->at(i) ) ); 564 564 } 565 565 } 566 566 ··· 572 572 } 573 573 574 574 // 4J-PB - replacing with a switch, rather than tons of ifs 575 575 - if (std::dynamic_pointer_cast<Creature>(e) != NULL) 575 575 + if (dynamic_pointer_cast<Creature>(e) != NULL) 576 576 { 577 577 yHeadRotp = Mth::floor(e->getYHeadRot() * 256 / 360); 578 578 - return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp) ); 578 578 + return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp) ); 579 579 } 580 580 581 581 switch(e->GetType()) ··· 588 588 break; 589 589 case eTYPE_SERVERPLAYER: 590 590 { 591 591 - std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e); 591 591 + std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e); 592 592 PlayerUID xuid = INVALID_XUID; 593 593 PlayerUID OnlineXuid = INVALID_XUID; 594 594 if( player != NULL ) ··· 597 597 OnlineXuid = player->getOnlineXuid(); 598 598 } 599 599 // 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. 600 600 - return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(std::dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp, yHeadRotp ) ); 600 600 + return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp, yHeadRotp ) ); 601 601 } 602 602 break; 603 603 case eTYPE_MINECART: 604 604 { 605 605 - std::shared_ptr<Minecart> minecart = std::dynamic_pointer_cast<Minecart>(e); 605 605 + std::shared_ptr<Minecart> minecart = dynamic_pointer_cast<Minecart>(e); 606 606 if (minecart->type == Minecart::RIDEABLE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_RIDEABLE, yRotp, xRotp, xp, yp, zp) ); 607 607 if (minecart->type == Minecart::CHEST) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_CHEST, yRotp, xRotp, xp, yp, zp) ); 608 608 if (minecart->type == Minecart::FURNACE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_FURNACE, yRotp, xRotp, xp, yp, zp) ); ··· 616 616 case eTYPE_ENDERDRAGON: 617 617 { 618 618 yHeadRotp = Mth::floor(e->getYHeadRot() * 256 / 360); 619 619 - return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp ) ); 619 619 + return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp ) ); 620 620 } 621 621 break; 622 622 case eTYPE_FISHINGHOOK: 623 623 { 624 624 - std::shared_ptr<Entity> owner = std::dynamic_pointer_cast<FishingHook>(e)->owner; 624 624 + std::shared_ptr<Entity> owner = dynamic_pointer_cast<FishingHook>(e)->owner; 625 625 return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FISH_HOOK, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) ); 626 626 } 627 627 break; 628 628 case eTYPE_ARROW: 629 629 { 630 630 - std::shared_ptr<Entity> owner = (std::dynamic_pointer_cast<Arrow>(e))->owner; 630 630 + std::shared_ptr<Entity> owner = (dynamic_pointer_cast<Arrow>(e))->owner; 631 631 return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ARROW, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) ); 632 632 } 633 633 break; ··· 638 638 break; 639 639 case eTYPE_THROWNPOTION: 640 640 { 641 641 - return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((std::dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp)); 641 641 + return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp)); 642 642 } 643 643 break; 644 644 case eTYPE_THROWNEXPBOTTLE: ··· 658 658 break; 659 659 case eTYPE_SMALL_FIREBALL: 660 660 { 661 661 - std::shared_ptr<SmallFireball> fb = std::dynamic_pointer_cast<SmallFireball>(e); 661 661 + std::shared_ptr<SmallFireball> fb = dynamic_pointer_cast<SmallFireball>(e); 662 662 std::shared_ptr<AddEntityPacket> aep = nullptr; 663 663 if (fb->owner != NULL) 664 664 { ··· 676 676 break; 677 677 case eTYPE_DRAGON_FIREBALL: 678 678 { 679 679 - std::shared_ptr<DragonFireball> fb = std::dynamic_pointer_cast<DragonFireball>(e); 679 679 + std::shared_ptr<DragonFireball> fb = dynamic_pointer_cast<DragonFireball>(e); 680 680 std::shared_ptr<AddEntityPacket> aep = nullptr; 681 681 if (fb->owner != NULL) 682 682 { ··· 694 694 break; 695 695 case eTYPE_FIREBALL: 696 696 { 697 697 - std::shared_ptr<Fireball> fb = std::dynamic_pointer_cast<Fireball>(e); 697 697 + std::shared_ptr<Fireball> fb = dynamic_pointer_cast<Fireball>(e); 698 698 std::shared_ptr<AddEntityPacket> aep = nullptr; 699 699 if (fb->owner != NULL) 700 700 { ··· 727 727 break; 728 728 case eTYPE_FALLINGTILE: 729 729 { 730 730 - std::shared_ptr<FallingTile> ft = std::dynamic_pointer_cast<FallingTile>(e); 730 730 + std::shared_ptr<FallingTile> ft = dynamic_pointer_cast<FallingTile>(e); 731 731 return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING, ft->tile | (ft->data << 16), yRotp, xRotp, xp, yp, zp) ); 732 732 } 733 733 break; 734 734 case eTYPE_PAINTING: 735 735 { 736 736 - return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(std::dynamic_pointer_cast<Painting>(e)) ); 736 736 + return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(dynamic_pointer_cast<Painting>(e)) ); 737 737 } 738 738 break; 739 739 case eTYPE_ITEM_FRAME: 740 740 { 741 741 - std::shared_ptr<ItemFrame> frame = std::dynamic_pointer_cast<ItemFrame>(e); 741 741 + std::shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame>(e); 742 742 { 743 743 744 744 int ix= (int)frame->xTile; ··· 756 756 break; 757 757 case eTYPE_EXPERIENCEORB: 758 758 { 759 759 - return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(std::dynamic_pointer_cast<ExperienceOrb>(e)) ); 759 759 + return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(dynamic_pointer_cast<ExperienceOrb>(e)) ); 760 760 } 761 761 break; 762 762 default: ··· 766 766 /* 767 767 if (e->GetType() == eTYPE_ITEMENTITY) 768 768 { 769 769 - std::shared_ptr<ItemEntity> itemEntity = std::dynamic_pointer_cast<ItemEntity>(e); 769 769 + std::shared_ptr<ItemEntity> itemEntity = dynamic_pointer_cast<ItemEntity>(e); 770 770 std::shared_ptr<AddItemEntityPacket> packet = std::shared_ptr<AddItemEntityPacket>( new AddItemEntityPacket(itemEntity, xp, yp, zp) ); 771 771 itemEntity->x = packet->x / 32.0; 772 772 itemEntity->y = packet->y / 32.0; ··· 776 776 777 777 if (e->GetType() == eTYPE_SERVERPLAYER ) 778 778 { 779 779 - std::shared_ptr<ServerPlayer> player = std::dynamic_pointer_cast<ServerPlayer>(e); 779 779 + std::shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e); 780 780 XUID xuid = INVALID_XUID; 781 781 XUID OnlineXuid = INVALID_XUID; 782 782 if( player != NULL ) ··· 784 784 xuid = player->getXuid(); 785 785 OnlineXuid = player->getOnlineXuid(); 786 786 } 787 787 - return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(std::dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp ) ); 787 787 + return std::shared_ptr<AddPlayerPacket>( new AddPlayerPacket(dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp ) ); 788 788 } 789 789 if (e->GetType() == eTYPE_MINECART) 790 790 { 791 791 - std::shared_ptr<Minecart> minecart = std::dynamic_pointer_cast<Minecart>(e); 791 791 + std::shared_ptr<Minecart> minecart = dynamic_pointer_cast<Minecart>(e); 792 792 if (minecart->type == Minecart::RIDEABLE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_RIDEABLE, yRotp, xRotp, xp, yp, zp) ); 793 793 if (minecart->type == Minecart::CHEST) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_CHEST, yRotp, xRotp, xp, yp, zp) ); 794 794 if (minecart->type == Minecart::FURNACE) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_FURNACE, yRotp, xRotp, xp, yp, zp) ); ··· 797 797 { 798 798 return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::BOAT, yRotp, xRotp, xp, yp, zp) ); 799 799 } 800 800 - if (std::dynamic_pointer_cast<Creature>(e) != NULL) 800 800 + if (dynamic_pointer_cast<Creature>(e) != NULL) 801 801 { 802 802 - return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp) ); 802 802 + return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp) ); 803 803 } 804 804 if (e->GetType() == eTYPE_ENDERDRAGON) 805 805 { 806 806 - return std::shared_ptr<AddMobPacket>( new AddMobPacket(std::dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp ) ); 806 806 + return std::shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp ) ); 807 807 } 808 808 if (e->GetType() == eTYPE_FISHINGHOOK) 809 809 { 810 810 - std::shared_ptr<Entity> owner = std::dynamic_pointer_cast<FishingHook>(e)->owner; 810 810 + std::shared_ptr<Entity> owner = dynamic_pointer_cast<FishingHook>(e)->owner; 811 811 return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FISH_HOOK, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) ); 812 812 } 813 813 if (e->GetType() == eTYPE_ARROW) 814 814 { 815 815 - std::shared_ptr<Entity> owner = (std::dynamic_pointer_cast<Arrow>(e))->owner; 815 815 + std::shared_ptr<Entity> owner = (dynamic_pointer_cast<Arrow>(e))->owner; 816 816 return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ARROW, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) ); 817 817 } 818 818 if (e->GetType() == eTYPE_SNOWBALL) ··· 821 821 } 822 822 if (e->GetType() == eTYPE_THROWNPOTION) 823 823 { 824 824 - return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((std::dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp)); 824 824 + return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp)); 825 825 } 826 826 if (e->GetType() == eTYPE_THROWNEXPBOTTLE) 827 827 { ··· 837 837 } 838 838 if (e->GetType() == eTYPE_SMALL_FIREBALL) 839 839 { 840 840 - std::shared_ptr<SmallFireball> fb = std::dynamic_pointer_cast<SmallFireball>(e); 840 840 + std::shared_ptr<SmallFireball> fb = dynamic_pointer_cast<SmallFireball>(e); 841 841 std::shared_ptr<AddEntityPacket> aep = NULL; 842 842 if (fb->owner != NULL) 843 843 { ··· 854 854 } 855 855 if (e->GetType() == eTYPE_FIREBALL) 856 856 { 857 857 - std::shared_ptr<Fireball> fb = std::dynamic_pointer_cast<Fireball>(e); 857 857 + std::shared_ptr<Fireball> fb = dynamic_pointer_cast<Fireball>(e); 858 858 std::shared_ptr<AddEntityPacket> aep = NULL; 859 859 if (fb->owner != NULL) 860 860 { ··· 883 883 } 884 884 if (e->GetType() == eTYPE_FALLINGTILE) 885 885 { 886 886 - std::shared_ptr<FallingTile> ft = std::dynamic_pointer_cast<FallingTile>(e); 886 886 + std::shared_ptr<FallingTile> ft = dynamic_pointer_cast<FallingTile>(e); 887 887 if (ft->tile == Tile::sand_Id) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_SAND, yRotp, xRotp, xp, yp, zp) ); 888 888 if (ft->tile == Tile::gravel_Id) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_GRAVEL, yRotp, xRotp, xp, yp, zp) ); 889 889 if (ft->tile == Tile::dragonEgg_Id) return std::shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_EGG, yRotp, xRotp, xp, yp, zp) ); 890 890 } 891 891 if (e->GetType() == eTYPE_PAINTING) 892 892 { 893 893 - return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(std::dynamic_pointer_cast<Painting>(e)) ); 893 893 + return std::shared_ptr<AddPaintingPacket>( new AddPaintingPacket(dynamic_pointer_cast<Painting>(e)) ); 894 894 } 895 895 if (e->GetType() == eTYPE_ITEM_FRAME) 896 896 { 897 897 - std::shared_ptr<ItemFrame> frame = std::dynamic_pointer_cast<ItemFrame>(e); 897 897 + std::shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame>(e); 898 898 { 899 899 900 900 int ix= (int)frame->xTile; ··· 911 911 } 912 912 if (e->GetType() == eTYPE_EXPERIENCEORB) 913 913 { 914 914 - return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(std::dynamic_pointer_cast<ExperienceOrb>(e)) ); 914 914 + return std::shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(dynamic_pointer_cast<ExperienceOrb>(e)) ); 915 915 } 916 916 assert(false); 917 917 */

+1 -1

Minecraft.Client/VillagerGolemModel.cpp

··· 61 61 62 62 void VillagerGolemModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r, float a) 63 63 { 64 64 - std::shared_ptr<VillagerGolem> vg = std::dynamic_pointer_cast<VillagerGolem>(mob); 64 64 + std::shared_ptr<VillagerGolem> vg = dynamic_pointer_cast<VillagerGolem>(mob); 65 65 int attackTick = vg->getAttackAnimationTick(); 66 66 if (attackTick > 0) 67 67 {

+2 -2

Minecraft.Client/VillagerGolemRenderer.cpp

··· 24 24 { 25 25 // 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity> we have here - 26 26 // do some casting around instead 27 27 - std::shared_ptr<VillagerGolem> mob = std::dynamic_pointer_cast<VillagerGolem>(_mob); 27 27 + std::shared_ptr<VillagerGolem> mob = dynamic_pointer_cast<VillagerGolem>(_mob); 28 28 MobRenderer::setupRotations(mob, bob, bodyRot, a); 29 29 if (mob->walkAnimSpeed < 0.01) return; 30 30 ··· 38 38 { 39 39 // 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity> we have here - 40 40 // do some casting around instead 41 41 - std::shared_ptr<VillagerGolem> mob = std::dynamic_pointer_cast<VillagerGolem>(_mob); 41 41 + std::shared_ptr<VillagerGolem> mob = dynamic_pointer_cast<VillagerGolem>(_mob); 42 42 MobRenderer::additionalRendering(mob, a); 43 43 if (mob->getOfferFlowerTick() == 0) return; 44 44

+1 -1

Minecraft.Client/VillagerRenderer.cpp

··· 31 31 { 32 32 // 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity> we have here - 33 33 // do some casting around instead 34 34 - std::shared_ptr<Villager> mob = std::dynamic_pointer_cast<Villager>(_mob); 34 34 + std::shared_ptr<Villager> mob = dynamic_pointer_cast<Villager>(_mob); 35 35 float s = 15 / 16.0f; 36 36 if (mob->getAge() < 0) 37 37 {

+1 -1

Minecraft.Client/WolfModel.cpp

··· 96 96 97 97 void WolfModel::prepareMobModel(std::shared_ptr<Mob> mob, float time, float r, float a) 98 98 { 99 99 - std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(mob); 99 99 + std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(mob); 100 100 101 101 if (wolf->isAngry()) 102 102 {

+2 -2

Minecraft.Client/WolfRenderer.cpp

··· 11 11 float WolfRenderer::getBob(std::shared_ptr<Mob> _mob, float a) 12 12 { 13 13 // 4J - dynamic cast required because we aren't using templates/generics in our version 14 14 - std::shared_ptr<Wolf> mob = std::dynamic_pointer_cast<Wolf>(_mob); 14 14 + std::shared_ptr<Wolf> mob = dynamic_pointer_cast<Wolf>(_mob); 15 15 16 16 return mob->getTailAngle(); 17 17 } ··· 20 20 { 21 21 if (mob->isInvisibleTo(Minecraft::GetInstance()->player)) return -1; // 4J-JEV: Todo, merge with java fix in '1.7.5'. 22 22 23 23 - std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(mob); 23 23 + std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(mob); 24 24 if (layer == 0 && wolf->isWet()) 25 25 { 26 26 float brightness = wolf->getBrightness(a) * wolf->getWetShade(a);

+4 -4

Minecraft.Client/ZombieRenderer.cpp

··· 36 36 37 37 int ZombieRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a) 38 38 { 39 39 - std::shared_ptr<Zombie> mob = std::dynamic_pointer_cast<Zombie>(_mob); 39 39 + std::shared_ptr<Zombie> mob = dynamic_pointer_cast<Zombie>(_mob); 40 40 swapArmor(mob); 41 41 return HumanoidMobRenderer::prepareArmor(_mob, layer, a); 42 42 } 43 43 44 44 void ZombieRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a) 45 45 { 46 46 - std::shared_ptr<Zombie> mob = std::dynamic_pointer_cast<Zombie>(_mob); 46 46 + std::shared_ptr<Zombie> mob = dynamic_pointer_cast<Zombie>(_mob); 47 47 swapArmor(mob); 48 48 HumanoidMobRenderer::render(_mob, x, y, z, rot, a); 49 49 } 50 50 51 51 void ZombieRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a) 52 52 { 53 53 - std::shared_ptr<Zombie> mob = std::dynamic_pointer_cast<Zombie>(_mob); 53 53 + std::shared_ptr<Zombie> mob = dynamic_pointer_cast<Zombie>(_mob); 54 54 swapArmor(mob); 55 55 HumanoidMobRenderer::additionalRendering(_mob, a); 56 56 } ··· 82 82 83 83 void ZombieRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a) 84 84 { 85 85 - std::shared_ptr<Zombie> mob = std::dynamic_pointer_cast<Zombie>(_mob); 85 85 + std::shared_ptr<Zombie> mob = dynamic_pointer_cast<Zombie>(_mob); 86 86 if (mob->isConverting()) 87 87 { 88 88 bodyRot += (float) (cos(mob->tickCount * 3.25) * PI * .25f);

+1 -1

Minecraft.World/AddGlobalEntityPacket.cpp

··· 26 26 x = Mth::floor(e->x * 32); 27 27 y = Mth::floor(e->y * 32); 28 28 z = Mth::floor(e->z * 32); 29 29 - if (std::dynamic_pointer_cast<LightningBolt>(e) != NULL) 29 29 + if (dynamic_pointer_cast<LightningBolt>(e) != NULL) 30 30 { 31 31 this->type = LIGHTNING; 32 32 }

+1 -1

Minecraft.World/AgableMob.cpp

··· 24 24 eINSTANCEOF classToSpawn = EntityIO::getClass(item->getAuxValue()); 25 25 if (classToSpawn != eTYPE_NOTSET && (classToSpawn & eTYPE_AGABLE_MOB) == eTYPE_AGABLE_MOB && classToSpawn == GetType() ) // 4J Added GetType() check to only spawn same type 26 26 { 27 27 - std::shared_ptr<AgableMob> offspring = getBreedOffspring(std::dynamic_pointer_cast<AgableMob>(shared_from_this())); 27 27 + std::shared_ptr<AgableMob> offspring = getBreedOffspring(dynamic_pointer_cast<AgableMob>(shared_from_this())); 28 28 if (offspring != NULL) 29 29 { 30 30 offspring->setAge(-20 * 60 * 20);

+10 -10

Minecraft.World/Animal.cpp

··· 64 64 65 65 void Animal::checkHurtTarget(std::shared_ptr<Entity> target, float d) 66 66 { 67 67 - if (std::dynamic_pointer_cast<Player>(target) != NULL) 67 67 + if (dynamic_pointer_cast<Player>(target) != NULL) 68 68 { 69 69 if (d < 3) 70 70 { ··· 75 75 holdGround = true; 76 76 } 77 77 78 78 - std::shared_ptr<Player> p = std::dynamic_pointer_cast<Player>(target); 78 78 + std::shared_ptr<Player> p = dynamic_pointer_cast<Player>(target); 79 79 if (p->getSelectedItem() != NULL && this->isFood(p->getSelectedItem())) 80 80 { 81 81 } ··· 85 85 } 86 86 87 87 } 88 88 - else if (std::dynamic_pointer_cast<Animal>(target) != NULL) 88 88 + else if (dynamic_pointer_cast<Animal>(target) != NULL) 89 89 { 90 90 - std::shared_ptr<Animal> a = std::dynamic_pointer_cast<Animal>(target); 90 90 + std::shared_ptr<Animal> a = dynamic_pointer_cast<Animal>(target); 91 91 if (getAge() > 0 && a->getAge() < 0) 92 92 { 93 93 if (d < 2.5) ··· 172 172 { 173 173 std::shared_ptr<Entity> source = dmgSource->getDirectEntity(); 174 174 175 175 - if (std::dynamic_pointer_cast<Player>(source) != NULL && !std::dynamic_pointer_cast<Player>(source)->isAllowedToAttackAnimals() ) 175 175 + if (dynamic_pointer_cast<Player>(source) != NULL && !dynamic_pointer_cast<Player>(source)->isAllowedToAttackAnimals() ) 176 176 { 177 177 return false; 178 178 } 179 179 180 180 if (source != NULL && source->GetType() == eTYPE_ARROW) 181 181 { 182 182 - std::shared_ptr<Arrow> arrow = std::dynamic_pointer_cast<Arrow>(source); 183 183 - if (std::dynamic_pointer_cast<Player>(arrow->owner) != NULL && ! std::dynamic_pointer_cast<Player>(arrow->owner)->isAllowedToAttackAnimals() ) 182 182 + std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(source); 183 183 + if (dynamic_pointer_cast<Player>(arrow->owner) != NULL && ! dynamic_pointer_cast<Player>(arrow->owner)->isAllowedToAttackAnimals() ) 184 184 { 185 185 return false; 186 186 } ··· 218 218 //for (int i = 0; i < others->size(); i++) 219 219 for(AUTO_VAR(it, others->begin()); it != others->end(); ++it) 220 220 { 221 221 - std::shared_ptr<Animal> p = std::dynamic_pointer_cast<Animal>(*it); 221 221 + std::shared_ptr<Animal> p = dynamic_pointer_cast<Animal>(*it); 222 222 if (p != shared_from_this() && p->getInLoveValue() > 0) 223 223 { 224 224 delete others; ··· 237 237 { 238 238 setDespawnProtected(); 239 239 240 240 - std::shared_ptr<Player> p = std::dynamic_pointer_cast<Player>(*it); 240 240 + std::shared_ptr<Player> p = dynamic_pointer_cast<Player>(*it); 241 241 if (p->getSelectedItem() != NULL && this->isFood(p->getSelectedItem())) 242 242 { 243 243 delete players; ··· 252 252 //for (int i = 0; i < others.size(); i++) 253 253 for(AUTO_VAR(it, others->begin()); it != others->end(); ++it) 254 254 { 255 255 - std::shared_ptr<Animal> p = std::dynamic_pointer_cast<Animal>(*it); 255 255 + std::shared_ptr<Animal> p = dynamic_pointer_cast<Animal>(*it); 256 256 if (p != shared_from_this() && p->getAge() < 0) 257 257 { 258 258 delete others;

+8 -8

Minecraft.World/Arrow.cpp

··· 57 57 _init(); 58 58 59 59 this->owner = mob; 60 60 - if ( std::dynamic_pointer_cast<Player>( mob ) != NULL) pickup = PICKUP_ALLOWED; 60 60 + if ( dynamic_pointer_cast<Player>( mob ) != NULL) pickup = PICKUP_ALLOWED; 61 61 62 62 y = mob->y + mob->getHeadHeight() - 0.1f; 63 63 ··· 94 94 _init(); 95 95 96 96 this->owner = mob; 97 97 - if ( std::dynamic_pointer_cast<Player>( mob ) != NULL) pickup = PICKUP_ALLOWED; 97 97 + if ( dynamic_pointer_cast<Player>( mob ) != NULL) pickup = PICKUP_ALLOWED; 98 98 99 99 setSize(0.5f, 0.5f); 100 100 ··· 281 281 DamageSource *damageSource = NULL; 282 282 if (owner == NULL) 283 283 { 284 284 - damageSource = DamageSource::arrow(std::dynamic_pointer_cast<Arrow>(shared_from_this()), shared_from_this()); 284 284 + damageSource = DamageSource::arrow(dynamic_pointer_cast<Arrow>(shared_from_this()), shared_from_this()); 285 285 } 286 286 else 287 287 { 288 288 - damageSource = DamageSource::arrow(std::dynamic_pointer_cast<Arrow>(shared_from_this()), owner); 288 288 + damageSource = DamageSource::arrow(dynamic_pointer_cast<Arrow>(shared_from_this()), owner); 289 289 } 290 290 291 291 if(res->entity->hurt(damageSource, dmg)) ··· 299 299 res->entity->setOnFire(5); 300 300 } 301 301 302 302 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(res->entity); 302 302 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(res->entity); 303 303 if (mob != NULL) 304 304 { 305 305 mob->arrowCount++; ··· 319 319 } 320 320 321 321 // 4J : WESTY : For award, need to track if creeper was killed by arrow from the player. 322 322 - if ( (std::dynamic_pointer_cast<Player>(owner) != NULL ) && // arrow owner is a player 322 322 + if ( (dynamic_pointer_cast<Player>(owner) != NULL ) && // arrow owner is a player 323 323 ( res->entity->isAlive() == false ) && // target is now dead 324 324 - ( std::dynamic_pointer_cast<Creeper>( res->entity ) != NULL ) ) // target is a creeper 324 324 + ( dynamic_pointer_cast<Creeper>( res->entity ) != NULL ) ) // target is a creeper 325 325 326 326 { 327 327 - std::dynamic_pointer_cast<Player>(owner)->awardStat( 327 327 + dynamic_pointer_cast<Player>(owner)->awardStat( 328 328 GenericStats::arrowKillCreeper(), 329 329 GenericStats::param_arrowKillCreeper() 330 330 );

+2 -2

Minecraft.World/ArrowAttackGoal.cpp

··· 72 72 std::shared_ptr<Mob> tar = target.lock(); 73 73 if (projectileType == ArrowType) 74 74 { 75 75 - 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) ); 75 75 + std::shared_ptr<Arrow> arrow = std::shared_ptr<Arrow>( new Arrow(level, dynamic_pointer_cast<Mob>(mob->shared_from_this()), tar, 1.60f, 12) ); 76 76 level->playSound(mob->shared_from_this(), eSoundType_RANDOM_BOW, 1.0f, 1 / (mob->getRandom()->nextFloat() * 0.4f + 0.8f)); 77 77 level->addEntity(arrow); 78 78 } 79 79 else if (projectileType == SnowballType) 80 80 { 81 81 - std::shared_ptr<Snowball> snowball = std::shared_ptr<Snowball>( new Snowball(level, std::dynamic_pointer_cast<Mob>(mob->shared_from_this())) ); 81 81 + std::shared_ptr<Snowball> snowball = std::shared_ptr<Snowball>( new Snowball(level, dynamic_pointer_cast<Mob>(mob->shared_from_this())) ); 82 82 double xd = tar->x - mob->x; 83 83 double yd = (tar->y + tar->getHeadHeight() - 1.1f) - snowball->y; 84 84 double zd = tar->z - mob->z;

+2 -2

Minecraft.World/AvoidPlayerGoal.cpp

··· 33 33 { 34 34 if (avoidType == typeid(Player)) 35 35 { 36 36 - std::shared_ptr<TamableAnimal> tamableAnimal = std::dynamic_pointer_cast<TamableAnimal>(mob->shared_from_this()); 36 36 + std::shared_ptr<TamableAnimal> tamableAnimal = dynamic_pointer_cast<TamableAnimal>(mob->shared_from_this()); 37 37 if (tamableAnimal != NULL && tamableAnimal->isTame()) return false; 38 38 toAvoid = weak_ptr<Entity>(mob->level->getNearestPlayer(mob->shared_from_this(), maxDist)); 39 39 if (toAvoid.lock() == NULL) return false; ··· 52 52 53 53 if (!mob->getSensing()->canSee(toAvoid.lock())) return false; 54 54 55 55 - 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)); 55 55 + 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)); 56 56 if (pos == NULL) return false; 57 57 if (toAvoid.lock()->distanceToSqr(pos->x, pos->y, pos->z) < toAvoid.lock()->distanceToSqr(mob->shared_from_this())) return false; 58 58 delete path;

+1 -1

Minecraft.World/Blaze.cpp

··· 154 154 level->levelEvent(nullptr, LevelEvent::SOUND_BLAZE_FIREBALL, (int) x, (int) y, (int) z, 0); 155 155 // level.playSound(this, "mob.ghast.fireball", getSoundVolume(), (random.nextFloat() - random.nextFloat()) * 0.2f + 1.0f); 156 156 for (int i = 0; i < 1; i++) { 157 157 - std::shared_ptr<SmallFireball> ie = std::shared_ptr<SmallFireball>( new SmallFireball(level, std::dynamic_pointer_cast<Mob>( shared_from_this() ), xd + random->nextGaussian() * sqd, yd, zd + random->nextGaussian() * sqd) ); 157 157 + std::shared_ptr<SmallFireball> ie = std::shared_ptr<SmallFireball>( new SmallFireball(level, dynamic_pointer_cast<Mob>( shared_from_this() ), xd + random->nextGaussian() * sqd, yd, zd + random->nextGaussian() * sqd) ); 158 158 // Vec3 v = getViewVector(1); 159 159 // ie.x = x + v.x * 1.5; 160 160 ie->y = y + bbHeight / 2 + 0.5f;

+4 -4

Minecraft.World/Boat.cpp

··· 100 100 { 101 101 std::shared_ptr<Entity> attacker = source->getDirectEntity(); 102 102 103 103 - if (std::dynamic_pointer_cast<Player>(attacker) != NULL && 104 104 - !std::dynamic_pointer_cast<Player>(attacker)->isAllowedToHurtEntity( shared_from_this() )) 103 103 + if (dynamic_pointer_cast<Player>(attacker) != NULL && 104 104 + !dynamic_pointer_cast<Player>(attacker)->isAllowedToHurtEntity( shared_from_this() )) 105 105 return false; 106 106 } 107 107 ··· 117 117 markHurt(); 118 118 119 119 // 4J Stu - Brought froward from 12w36 to fix #46611 - TU5: Gameplay: Minecarts and boat requires more hits than one to be destroyed in creative mode 120 120 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(source->getEntity()); 120 120 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(source->getEntity()); 121 121 if (player != NULL && player->abilities.instabuild) setDamage(100); 122 122 123 123 if (getDamage() > 20 * 2) ··· 469 469 470 470 bool Boat::interact(std::shared_ptr<Player> player) 471 471 { 472 472 - if (rider.lock() != NULL && std::dynamic_pointer_cast<Player>(rider.lock())!=NULL && rider.lock() != player) return true; 472 472 + if (rider.lock() != NULL && dynamic_pointer_cast<Player>(rider.lock())!=NULL && rider.lock() != player) return true; 473 473 if (!level->isClientSide) 474 474 { 475 475 // 4J HEG - Fixed issue with player not being able to dismount boat (issue #4446)

+1 -1

Minecraft.World/BonusChestFeature.cpp

··· 58 58 if (force || ( level->isEmptyTile(x2, y2, z2) && level->isTopSolidBlocking(x2, y2 - 1, z2))) 59 59 { 60 60 level->setTile(x2, y2, z2, Tile::chest_Id); 61 61 - std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x2, y2, z2)); 61 61 + std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x2, y2, z2)); 62 62 if (chest != NULL) 63 63 { 64 64 WeighedTreasure::addChestItems(random, treasureList, chest, numRolls);

+1 -1

Minecraft.World/BossMobPart.cpp

··· 34 34 35 35 bool BossMobPart::hurt(DamageSource *source, int damage) 36 36 { 37 37 - return bossMob->hurt( std::dynamic_pointer_cast<BossMobPart>( shared_from_this() ), source, damage); 37 37 + return bossMob->hurt( dynamic_pointer_cast<BossMobPart>( shared_from_this() ), source, damage); 38 38 } 39 39 40 40 bool BossMobPart::is(std::shared_ptr<Entity> other)

+1 -1

Minecraft.World/BreedGoal.cpp

··· 52 52 vector<std::shared_ptr<Entity> > *others = level->getEntitiesOfClass(typeid(*animal), animal->bb->grow(r, r, r)); 53 53 for(AUTO_VAR(it, others->begin()); it != others->end(); ++it) 54 54 { 55 55 - std::shared_ptr<Animal> p = std::dynamic_pointer_cast<Animal>(*it); 55 55 + std::shared_ptr<Animal> p = dynamic_pointer_cast<Animal>(*it); 56 56 if (animal->canMate(p)) 57 57 { 58 58 delete others;

+4 -4

Minecraft.World/BrewingStandMenu.cpp

··· 12 12 13 13 this->brewingStand = brewingStand; 14 14 15 15 - addSlot(new PotionSlot(std::dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 0, 56, 46)); 16 16 - addSlot(new PotionSlot(std::dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 1, 79, 53)); 17 17 - addSlot(new PotionSlot(std::dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 2, 102, 46)); 15 15 + addSlot(new PotionSlot(dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 0, 56, 46)); 16 16 + addSlot(new PotionSlot(dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 1, 79, 53)); 17 17 + addSlot(new PotionSlot(dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), brewingStand, 2, 102, 46)); 18 18 ingredientSlot = addSlot(new IngredientsSlot(brewingStand, 3, 79, 17)); 19 19 20 20 for (int y = 0; y < 3; y++) ··· 190 190 191 191 void BrewingStandMenu::PotionSlot::onTake(std::shared_ptr<Player> player, std::shared_ptr<ItemInstance> carried) 192 192 { 193 193 - carried->onCraftedBy(this->player->level, std::dynamic_pointer_cast<Player>( this->player->shared_from_this() ), 1); 193 193 + carried->onCraftedBy(this->player->level, dynamic_pointer_cast<Player>( this->player->shared_from_this() ), 1); 194 194 if (carried->id == Item::potion_Id && carried->getAuxValue() > 0) 195 195 this->player->awardStat(GenericStats::potion(),GenericStats::param_potion()); 196 196 Slot::onTake(player, carried);

+3 -3

Minecraft.World/BrewingStandTile.cpp

··· 60 60 { 61 61 return true; 62 62 } 63 63 - std::shared_ptr<BrewingStandTileEntity> brewingStand = std::dynamic_pointer_cast<BrewingStandTileEntity>(level->getTileEntity(x, y, z)); 63 63 + std::shared_ptr<BrewingStandTileEntity> brewingStand = dynamic_pointer_cast<BrewingStandTileEntity>(level->getTileEntity(x, y, z)); 64 64 if (brewingStand != NULL) player->openBrewingStand(brewingStand); 65 65 66 66 return true; ··· 79 79 void BrewingStandTile::onRemove(Level *level, int x, int y, int z, int id, int data) 80 80 { 81 81 std::shared_ptr<TileEntity> tileEntity = level->getTileEntity(x, y, z); 82 82 - if (tileEntity != NULL && ( std::dynamic_pointer_cast<BrewingStandTileEntity>(tileEntity) != NULL) ) 82 82 + if (tileEntity != NULL && ( dynamic_pointer_cast<BrewingStandTileEntity>(tileEntity) != NULL) ) 83 83 { 84 84 - std::shared_ptr<BrewingStandTileEntity> container = std::dynamic_pointer_cast<BrewingStandTileEntity>(tileEntity); 84 84 + std::shared_ptr<BrewingStandTileEntity> container = dynamic_pointer_cast<BrewingStandTileEntity>(tileEntity); 85 85 for (int i = 0; i < container->getContainerSize(); i++) 86 86 { 87 87 std::shared_ptr<ItemInstance> item = container->getItem(i);

+1 -1

Minecraft.World/BucketItem.cpp

··· 120 120 if (!level->mayInteract(player, xt, yt, zt,content)) 121 121 { 122 122 app.DebugPrintf("!!!!!!!!!!! Can't place that here\n"); 123 123 - std::shared_ptr<ServerPlayer> servPlayer = std::dynamic_pointer_cast<ServerPlayer>(player); 123 123 + std::shared_ptr<ServerPlayer> servPlayer = dynamic_pointer_cast<ServerPlayer>(player); 124 124 if( servPlayer != NULL ) 125 125 { 126 126 app.DebugPrintf("Sending ChatPacket::e_ChatCannotPlaceLava to player\n");

+1 -1

Minecraft.World/CarrotOnAStickItem.cpp

··· 25 25 { 26 26 if (player->isRiding()) 27 27 { 28 28 - std::shared_ptr<Pig> pig = std::dynamic_pointer_cast<Pig>(player->riding); 28 28 + std::shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(player->riding); 29 29 if(pig) 30 30 { 31 31 if (pig->getControlGoal()->canBoost() && itemInstance->getMaxDamage() - itemInstance->getAuxValue() >= 7)

+2 -2

Minecraft.World/CauldronTile.cpp

··· 123 123 level->addEntity(std::shared_ptr<ItemEntity>(new ItemEntity(level, x + 0.5, y + 1.5, z + 0.5, potion))); 124 124 } 125 125 // 4J Stu - Brought forward change to update inventory when filling bottles with water 126 126 - else if (std::dynamic_pointer_cast<ServerPlayer>( player ) != NULL) 126 126 + else if (dynamic_pointer_cast<ServerPlayer>( player ) != NULL) 127 127 { 128 128 - std::dynamic_pointer_cast<ServerPlayer>( player )->refreshContainer(player->inventoryMenu); 128 128 + dynamic_pointer_cast<ServerPlayer>( player )->refreshContainer(player->inventoryMenu); 129 129 } 130 130 // 4J-PB - don't lose the water in creative mode 131 131 if (player->abilities.instabuild==false)

+2 -2

Minecraft.World/CaveSpider.cpp

··· 32 32 { 33 33 if (Spider::doHurtTarget(target)) 34 34 { 35 35 - if ( std::dynamic_pointer_cast<Mob>(target) != NULL) 35 35 + if ( dynamic_pointer_cast<Mob>(target) != NULL) 36 36 { 37 37 int poisonTime = 0; 38 38 if (level->difficulty <= Difficulty::EASY) ··· 49 49 } 50 50 51 51 if (poisonTime > 0) { 52 52 - std::dynamic_pointer_cast<Mob>(target)->addEffect(new MobEffectInstance(MobEffect::poison->id, poisonTime * SharedConstants::TICKS_PER_SECOND, 0)); 52 52 + dynamic_pointer_cast<Mob>(target)->addEffect(new MobEffectInstance(MobEffect::poison->id, poisonTime * SharedConstants::TICKS_PER_SECOND, 0)); 53 53 } 54 54 } 55 55

+8 -8

Minecraft.World/ChestTile.cpp

··· 200 200 void ChestTile::neighborChanged(Level *level, int x, int y, int z, int type) 201 201 { 202 202 EntityTile::neighborChanged(level, x, y, z, type); 203 203 - std::shared_ptr<ChestTileEntity>(cte) = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z)); 203 203 + std::shared_ptr<ChestTileEntity>(cte) = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z)); 204 204 if (cte != NULL) cte->clearCache(); 205 205 } 206 206 207 207 void ChestTile::onRemove(Level *level, int x, int y, int z, int id, int data) 208 208 { 209 209 - std::shared_ptr<Container> container = std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z) ); 209 209 + std::shared_ptr<Container> container = dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z) ); 210 210 if (container != NULL ) 211 211 { 212 212 for (unsigned int i = 0; i < container->getContainerSize(); i++) ··· 263 263 return true; 264 264 } 265 265 266 266 - std::shared_ptr<Container> container = std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z) ); 266 266 + std::shared_ptr<Container> container = dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z) ); 267 267 if (container == NULL) return true; 268 268 269 269 if (level->isSolidBlockingTile(x, y + 1, z)) return true; ··· 274 274 if (level->getTile(x, y, z - 1) == id && (level->isSolidBlockingTile(x, y + 1, z - 1) || isCatSittingOnChest(level, x, y, z - 1))) return true; 275 275 if (level->getTile(x, y, z + 1) == id && (level->isSolidBlockingTile(x, y + 1, z + 1) || isCatSittingOnChest(level, x, y, z + 1))) return true; 276 276 277 277 - if (level->getTile(x - 1, y, z) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x - 1, y, z) ), container) ); 278 278 - if (level->getTile(x + 1, y, z) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, container, std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x + 1, y, z) )) ); 279 279 - if (level->getTile(x, y, z - 1) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z - 1) ), container) ); 280 280 - if (level->getTile(x, y, z + 1) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, container, std::dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z + 1) )) ); 277 277 + if (level->getTile(x - 1, y, z) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x - 1, y, z) ), container) ); 278 278 + if (level->getTile(x + 1, y, z) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, container, dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x + 1, y, z) )) ); 279 279 + if (level->getTile(x, y, z - 1) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z - 1) ), container) ); 280 280 + if (level->getTile(x, y, z + 1) == id) container = std::shared_ptr<Container>( new CompoundContainer(IDS_CHEST_LARGE, container, dynamic_pointer_cast<ChestTileEntity>( level->getTileEntity(x, y, z + 1) )) ); 281 281 282 282 player->openContainer(container); 283 283 ··· 290 290 vector<std::shared_ptr<Entity> > *entities = level->getEntitiesOfClass(typeid(Ozelot), AABB::newTemp(x, y + 1, z, x + 1, y + 2, z + 1)); 291 291 for(AUTO_VAR(it, entities->begin()); it != entities->end(); ++it) 292 292 { 293 293 - std::shared_ptr<Ozelot> ocelot = std::dynamic_pointer_cast<Ozelot>(*it); 293 293 + std::shared_ptr<Ozelot> ocelot = dynamic_pointer_cast<Ozelot>(*it); 294 294 if(ocelot->isSitting()) 295 295 { 296 296 return true;

+4 -4

Minecraft.World/ChestTileEntity.cpp

··· 165 165 166 166 if (level->getTile(x - 1, y, z) == Tile::chest_Id) 167 167 { 168 168 - w = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x - 1, y, z)); 168 168 + w = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x - 1, y, z)); 169 169 } 170 170 if (level->getTile(x + 1, y, z) == Tile::chest_Id) 171 171 { 172 172 - e = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x + 1, y, z)); 172 172 + e = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x + 1, y, z)); 173 173 } 174 174 if (level->getTile(x, y, z - 1) == Tile::chest_Id) 175 175 { 176 176 - n = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z - 1)); 176 176 + n = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z - 1)); 177 177 } 178 178 if (level->getTile(x, y, z + 1) == Tile::chest_Id) 179 179 { 180 180 - s = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z + 1)); 180 180 + s = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z + 1)); 181 181 } 182 182 183 183 if (n.lock() != NULL) n.lock()->clearCache();

+1 -1

Minecraft.World/ClientCommandPacket.cpp

··· 24 24 25 25 void ClientCommandPacket::handle(PacketListener *listener) 26 26 { 27 27 - listener->handleClientCommand(std::dynamic_pointer_cast<ClientCommandPacket>(shared_from_this())); 27 27 + listener->handleClientCommand(dynamic_pointer_cast<ClientCommandPacket>(shared_from_this())); 28 28 } 29 29 30 30 int ClientCommandPacket::getEstimatedSize()

+1 -1

Minecraft.World/ContainerMenu.cpp

··· 90 90 std::shared_ptr<ItemInstance> out = AbstractContainerMenu::clicked(slotIndex, buttonNum, clickType, player); 91 91 92 92 #ifdef _EXTENDED_ACHIEVEMENTS 93 93 - std::shared_ptr<LocalPlayer> localPlayer = std::dynamic_pointer_cast<LocalPlayer>(player); 93 93 + std::shared_ptr<LocalPlayer> localPlayer = dynamic_pointer_cast<LocalPlayer>(player); 94 94 95 95 if (localPlayer != NULL) // 4J-JEV: For "Chestful o'Cobblestone" achievement. 96 96 {

+2 -2

Minecraft.World/ControlledByPlayerGoal.cpp

··· 36 36 37 37 bool ControlledByPlayerGoal::canUse() 38 38 { 39 39 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( mob->rider.lock() ); 39 39 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( mob->rider.lock() ); 40 40 return mob->isAlive() && player && (boosting || mob->canBeControlledByRider()); 41 41 } 42 42 43 43 void ControlledByPlayerGoal::tick() 44 44 { 45 45 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mob->rider.lock()); 45 45 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob->rider.lock()); 46 46 PathfinderMob *pig = (PathfinderMob *)mob; 47 47 48 48 float yrd = Mth::wrapDegrees(player->yRot - mob->yRot) * 0.5f;

+3 -3

Minecraft.World/Creeper.cpp

··· 120 120 { 121 121 Monster::die(source); 122 122 123 123 - if ( std::dynamic_pointer_cast<Skeleton>(source->getEntity()) != NULL ) 123 123 + if ( dynamic_pointer_cast<Skeleton>(source->getEntity()) != NULL ) 124 124 { 125 125 spawnAtLocation(Item::record_01_Id + random->nextInt(12), 1); 126 126 } 127 127 128 128 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(source->getEntity()); 129 129 - if ( (std::dynamic_pointer_cast<Arrow>(source->getDirectEntity()) != NULL) && (player != NULL) ) 128 128 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(source->getEntity()); 129 129 + if ( (dynamic_pointer_cast<Arrow>(source->getDirectEntity()) != NULL) && (player != NULL) ) 130 130 { 131 131 player->awardStat(GenericStats::archer(), GenericStats::param_archer()); 132 132 }

+1 -1

Minecraft.World/DefendVillageTargetGoal.cpp

··· 13 13 { 14 14 std::shared_ptr<Village> village = golem->getVillage(); 15 15 if (village == NULL) return false; 16 16 - potentialTarget = weak_ptr<Mob>(village->getClosestAggressor(std::dynamic_pointer_cast<Mob>(golem->shared_from_this()))); 16 16 + potentialTarget = weak_ptr<Mob>(village->getClosestAggressor(dynamic_pointer_cast<Mob>(golem->shared_from_this()))); 17 17 return canAttack(potentialTarget.lock(), false); 18 18 } 19 19

+4 -4

Minecraft.World/DispenserTile.cpp

··· 107 107 return true; 108 108 } 109 109 110 110 - std::shared_ptr<DispenserTileEntity> trap = std::dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) ); 110 110 + std::shared_ptr<DispenserTileEntity> trap = dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) ); 111 111 player->openTrap(trap); 112 112 113 113 return true; ··· 138 138 xd = -1; 139 139 } 140 140 141 141 - std::shared_ptr<DispenserTileEntity> trap = std::dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) ); 141 141 + std::shared_ptr<DispenserTileEntity> trap = dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) ); 142 142 if(trap != NULL) 143 143 { 144 144 int slot=trap->getRandomSlot(); ··· 207 207 208 208 void DispenserTile::onRemove(Level *level, int x, int y, int z, int id, int data) 209 209 { 210 210 - std::shared_ptr<Container> container = std::dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) ); 210 210 + std::shared_ptr<Container> container = dynamic_pointer_cast<DispenserTileEntity>( level->getTileEntity(x, y, z) ); 211 211 if (container != NULL ) 212 212 { 213 213 for (unsigned int i = 0; i < container->getContainerSize(); i++) ··· 422 422 //MonsterPlacerItem *spawnEgg = (MonsterPlacerItem *)item->getItem(); 423 423 std::shared_ptr<Entity> newEntity = MonsterPlacerItem::canSpawn(item->getAuxValue(), level,&iResult); 424 424 425 425 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(newEntity); 425 425 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(newEntity); 426 426 if (mob != NULL) 427 427 { 428 428 // 4J-PB - Changed the line below slightly since mobs were sticking to the dispenser rather than dropping down when fired

+1 -1

Minecraft.World/DragonFireball.cpp

··· 40 40 for( AUTO_VAR(it, entitiesOfClass->begin()); it != entitiesOfClass->end(); ++it) 41 41 { 42 42 //std::shared_ptr<Entity> e = *it; 43 43 - std::shared_ptr<Mob> e = std::dynamic_pointer_cast<Mob>( *it ); 43 43 + std::shared_ptr<Mob> e = dynamic_pointer_cast<Mob>( *it ); 44 44 double dist = distanceToSqr(e); 45 45 if (dist < SPLASH_RANGE_SQ) 46 46 {

+2 -2

Minecraft.World/DyePowderItem.cpp

··· 291 291 292 292 bool DyePowderItem::interactEnemy(std::shared_ptr<ItemInstance> itemInstance, std::shared_ptr<Mob> mob) 293 293 { 294 294 - if (std::dynamic_pointer_cast<Sheep>( mob ) != NULL) 294 294 + if (dynamic_pointer_cast<Sheep>( mob ) != NULL) 295 295 { 296 296 - std::shared_ptr<Sheep> sheep = std::dynamic_pointer_cast<Sheep>(mob); 296 296 + std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(mob); 297 297 // convert to tile-based color value (0 is white instead of black) 298 298 int newColor = ClothTile::getTileDataForItemAuxValue(itemInstance->getAuxValue()); 299 299 if (!sheep->isSheared() && sheep->getColor() != newColor)

+2 -2

Minecraft.World/EggItem.cpp

··· 25 25 { 26 26 instance->count--; 27 27 } 28 28 - level->playSound( std::dynamic_pointer_cast<Entity>(player), eSoundType_RANDOM_BOW, 0.5f, 0.4f / (random->nextFloat() * 0.4f + 0.8f)); 29 29 - if (!level->isClientSide) level->addEntity( std::shared_ptr<ThrownEgg>( new ThrownEgg(level, std::dynamic_pointer_cast<Mob>( player )) )); 28 28 + level->playSound( dynamic_pointer_cast<Entity>(player), eSoundType_RANDOM_BOW, 0.5f, 0.4f / (random->nextFloat() * 0.4f + 0.8f)); 29 29 + if (!level->isClientSide) level->addEntity( std::shared_ptr<ThrownEgg>( new ThrownEgg(level, dynamic_pointer_cast<Mob>( player )) )); 30 30 return instance; 31 31 }

+1 -1

Minecraft.World/EnderChestTile.cpp

··· 64 64 bool EnderChestTile::use(Level *level, int x, int y, int z, std::shared_ptr<Player> player, int clickedFace, float clickX, float clickY, float clickZ, bool soundOnly) 65 65 { 66 66 std::shared_ptr<PlayerEnderChestContainer> container = player->getEnderChestInventory(); 67 67 - std::shared_ptr<EnderChestTileEntity> enderChest = std::dynamic_pointer_cast<EnderChestTileEntity>(level->getTileEntity(x, y, z)); 67 67 + std::shared_ptr<EnderChestTileEntity> enderChest = dynamic_pointer_cast<EnderChestTileEntity>(level->getTileEntity(x, y, z)); 68 68 if (container == NULL || enderChest == NULL) return true; 69 69 70 70 if (level->isSolidBlockingTile(x, y + 1, z)) return true;

+2 -2

Minecraft.World/EnderCrystal.cpp

··· 91 91 bool EnderCrystal::hurt(DamageSource *source, int damage) 92 92 { 93 93 // 4J-PB - if the owner of the source is the enderdragon, then ignore it (where the dragon's fireball hits an endercrystal) 94 94 - std::shared_ptr<EnderDragon> sourceIsDragon = std::dynamic_pointer_cast<EnderDragon>(source->getEntity()); 94 94 + std::shared_ptr<EnderDragon> sourceIsDragon = dynamic_pointer_cast<EnderDragon>(source->getEntity()); 95 95 96 96 if(sourceIsDragon!=NULL) 97 97 { ··· 114 114 for (AUTO_VAR(it, entities.begin()); it != itEnd; it++) 115 115 { 116 116 std::shared_ptr<Entity> e = *it; //entities->at(i); 117 117 - dragon = std::dynamic_pointer_cast<EnderDragon>(e); 117 117 + dragon = dynamic_pointer_cast<EnderDragon>(e); 118 118 if(dragon != NULL) 119 119 { 120 120 dragon->handleCrystalDestroyed(source);

+9 -9

Minecraft.World/EnderDragon.cpp

··· 444 444 445 445 for( AUTO_VAR(it, targets->begin() ); it != targets->end(); ++it) 446 446 { 447 447 - std::shared_ptr<Mob> e = std::dynamic_pointer_cast<Mob>( *it ); 447 447 + std::shared_ptr<Mob> e = dynamic_pointer_cast<Mob>( *it ); 448 448 if (e != NULL) 449 449 { 450 450 //app.DebugPrintf("Attacking entity with acid\n"); ··· 734 734 double zdd = attackTarget->z - startingZ; 735 735 736 736 level->levelEvent(nullptr, LevelEvent::SOUND_GHAST_FIREBALL, (int) x, (int) y, (int) z, 0); 737 737 - std::shared_ptr<DragonFireball> ie = std::shared_ptr<DragonFireball>( new DragonFireball(level, std::dynamic_pointer_cast<Mob>( shared_from_this() ), xdd, ydd, zdd) ); 737 737 + std::shared_ptr<DragonFireball> ie = std::shared_ptr<DragonFireball>( new DragonFireball(level, dynamic_pointer_cast<Mob>( shared_from_this() ), xdd, ydd, zdd) ); 738 738 ie->x = startingX; 739 739 ie->y = startingY; 740 740 ie->z = startingZ; ··· 800 800 //for (Entity ec : crystals) 801 801 for(AUTO_VAR(it, crystals->begin()); it != crystals->end(); ++it) 802 802 { 803 803 - std::shared_ptr<EnderCrystal> ec = std::dynamic_pointer_cast<EnderCrystal>( *it ); 803 803 + std::shared_ptr<EnderCrystal> ec = dynamic_pointer_cast<EnderCrystal>( *it ); 804 804 double dist = ec->distanceToSqr(shared_from_this() ); 805 805 if (dist < nearest) 806 806 { ··· 840 840 //for (Entity e : entities) 841 841 for(AUTO_VAR(it, entities->begin()); it != entities->end(); ++it) 842 842 { 843 843 - std::shared_ptr<Mob> e = std::dynamic_pointer_cast<Mob>( *it ); 843 843 + std::shared_ptr<Mob> e = dynamic_pointer_cast<Mob>( *it ); 844 844 if (e != NULL)//(e instanceof Mob) 845 845 { 846 846 double xd = e->x - xm; ··· 856 856 //for (int i = 0; i < entities->size(); i++) 857 857 for(AUTO_VAR(it, entities->begin()); it != entities->end(); ++it) 858 858 { 859 859 - std::shared_ptr<Mob> e = std::dynamic_pointer_cast<Mob>( *it );//entities.get(i); 859 859 + std::shared_ptr<Mob> e = dynamic_pointer_cast<Mob>( *it );//entities.get(i); 860 860 if (e != NULL) //(e instanceof Mob) 861 861 { 862 862 - DamageSource *damageSource = DamageSource::mobAttack( std::dynamic_pointer_cast<Mob>( shared_from_this() )); 862 862 + DamageSource *damageSource = DamageSource::mobAttack( dynamic_pointer_cast<Mob>( shared_from_this() )); 863 863 e->hurt(damageSource, 10); 864 864 delete damageSource; 865 865 } ··· 1116 1116 //zTarget = z - cc1 * 5 + (random->nextFloat() - 0.5f) * 2; 1117 1117 //attackTarget = NULL; 1118 1118 1119 1119 - if (source == DamageSource::explosion || (std::dynamic_pointer_cast<Player>(source->getEntity()) != NULL)) 1119 1119 + if (source == DamageSource::explosion || (dynamic_pointer_cast<Player>(source->getEntity()) != NULL)) 1120 1120 { 1121 1121 int healthBefore = health; 1122 1122 reallyHurt(source, damage); ··· 1461 1461 #endif 1462 1462 } 1463 1463 } 1464 1464 - else if(std::dynamic_pointer_cast<Player>(source->getEntity()) != NULL) 1464 1464 + else if(dynamic_pointer_cast<Player>(source->getEntity()) != NULL) 1465 1465 { 1466 1466 if(setSynchedAction(e_EnderdragonAction_StrafePlayer)) 1467 1467 { 1468 1468 - attackTarget = std::dynamic_pointer_cast<Player>(source->getEntity()); 1468 1468 + attackTarget = dynamic_pointer_cast<Player>(source->getEntity()); 1469 1469 #if PRINT_DRAGON_STATE_CHANGE_MESSAGES 1470 1470 app.DebugPrintf("Dragon action is now: StrafePlayer\n"); 1471 1471 #endif

+1 -1

Minecraft.World/EnderMan.cpp

··· 211 211 { 212 212 if (attackTarget != NULL) 213 213 { 214 214 - if ( std::dynamic_pointer_cast<Player>(attackTarget) != NULL && isLookingAtMe(std::dynamic_pointer_cast<Player>(attackTarget))) 214 214 + if ( dynamic_pointer_cast<Player>(attackTarget) != NULL && isLookingAtMe(dynamic_pointer_cast<Player>(attackTarget))) 215 215 { 216 216 xxa = yya = 0; 217 217 runSpeed = 0;

+3 -3

Minecraft.World/Entity.cpp

··· 670 670 671 671 AABB *bbOrg = bb->copy(); 672 672 673 673 - bool isPlayerSneaking = onGround && isSneaking() && std::dynamic_pointer_cast<Player>(shared_from_this()) != NULL; 673 673 + bool isPlayerSneaking = onGround && isSneaking() && dynamic_pointer_cast<Player>(shared_from_this()) != NULL; 674 674 675 675 if (isPlayerSneaking) 676 676 { ··· 1001 1001 { 1002 1002 if (fallDistance > 0) 1003 1003 { 1004 1004 - if (std::dynamic_pointer_cast<Mob>(shared_from_this()) != NULL) 1004 1004 + if (dynamic_pointer_cast<Mob>(shared_from_this()) != NULL) 1005 1005 { 1006 1006 int xt = Mth::floor(x); 1007 1007 int yt = Mth::floor(y - 0.2f - this->heightOffset); ··· 1534 1534 std::shared_ptr<Entity> lockedRider = rider.lock(); 1535 1535 if( lockedRider ) 1536 1536 { 1537 1537 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(lockedRider); 1537 1537 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(lockedRider); 1538 1538 if (!(player && player->isLocalPlayer())) 1539 1539 { 1540 1540 lockedRider->xOld = xOld;

+2 -2

Minecraft.World/EntityDamageSource.cpp

··· 26 26 wstring additional = L""; 27 27 if(entity->GetType() == eTYPE_SERVERPLAYER) 28 28 { 29 29 - std::shared_ptr<Player> sourcePlayer = std::dynamic_pointer_cast<Player>(entity); 29 29 + std::shared_ptr<Player> sourcePlayer = dynamic_pointer_cast<Player>(entity); 30 30 if(sourcePlayer != NULL) additional = sourcePlayer->name; 31 31 } 32 32 return std::shared_ptr<ChatPacket>( new ChatPacket(player->name, m_msgId, entity->GetType(), additional ) ); ··· 34 34 35 35 bool EntityDamageSource::scalesWithDifficulty() 36 36 { 37 37 - return entity != NULL && std::dynamic_pointer_cast<Mob>(entity) && !(std::dynamic_pointer_cast<Player>(entity)); 37 37 + return entity != NULL && dynamic_pointer_cast<Mob>(entity) && !(dynamic_pointer_cast<Player>(entity)); 38 38 }

+1 -1

Minecraft.World/Explosion.cpp

··· 149 149 e->yd += ya * push; 150 150 e->zd += za * push; 151 151 152 152 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e); 152 152 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e); 153 153 if (player != NULL) 154 154 { 155 155 //app.DebugPrintf("Adding player knockback (%f,%f,%f)\n", xa * pow, ya * pow, za * pow);

+1 -1

Minecraft.World/FarmTile.cpp

··· 81 81 if (!level->isClientSide && level->random->nextFloat() < (fallDistance - .5f)) 82 82 { 83 83 // Fix for #60547 - TU7: Content: Gameplay: Players joining a game can destroy crops even with Trust Players option disabled. 84 84 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(entity); 84 84 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(entity); 85 85 if(player == NULL || player->isAllowedToMine()) level->setTile(x, y, z, Tile::dirt_Id); 86 86 } 87 87 }

+2 -2

Minecraft.World/Fireball.cpp

··· 298 298 { 299 299 if (res->entity != NULL) 300 300 { 301 301 - DamageSource *damageSource = DamageSource::fireball(std::dynamic_pointer_cast<Fireball>( shared_from_this() ), owner); 301 301 + DamageSource *damageSource = DamageSource::fireball(dynamic_pointer_cast<Fireball>( shared_from_this() ), owner); 302 302 if (res->entity->hurt(damageSource, 6)) 303 303 { 304 304 } ··· 374 374 yPower = yd * 0.1; 375 375 zPower = zd * 0.1; 376 376 } 377 377 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>( source->getEntity() ); 377 377 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>( source->getEntity() ); 378 378 if (mob != NULL) 379 379 { 380 380 owner = mob;

+3 -3

Minecraft.World/FishingHook.cpp

··· 58 58 59 59 this->owner = owner; 60 60 // 4J Stu - Moved this outside the ctor 61 61 - //owner->fishing = std::dynamic_pointer_cast<FishingHook>( shared_from_this() ); 61 61 + //owner->fishing = dynamic_pointer_cast<FishingHook>( shared_from_this() ); 62 62 63 63 setPos(x, y, z); 64 64 } ··· 69 69 70 70 this->owner = mob; 71 71 // 4J Stu - Moved this outside the ctor 72 72 - //owner->fishing = std::dynamic_pointer_cast<FishingHook>( shared_from_this() ); 72 72 + //owner->fishing = dynamic_pointer_cast<FishingHook>( shared_from_this() ); 73 73 74 74 this->moveTo(mob->x, mob->y + 1.62 - mob->heightOffset, mob->z, mob->yRot, mob->xRot); 75 75 ··· 265 265 if (res->entity != NULL) 266 266 { 267 267 // 4J Stu Move fix for : fix for #48587 - CRASH: Code: Gameplay: Hitting another player with the fishing bobber crashes the game. [Fishing pole, line] 268 268 - // Incorrect std::dynamic_pointer_cast used around the shared_from_this() 268 268 + // Incorrect dynamic_pointer_cast used around the shared_from_this() 269 269 DamageSource *damageSource = DamageSource::thrown(shared_from_this(), owner); 270 270 if (res->entity->hurt(damageSource, 0)) 271 271 {

+1 -1

Minecraft.World/FollowParentGoal.cpp

··· 24 24 double closestDistSqr = Double::MAX_VALUE; 25 25 for(AUTO_VAR(it, parents->begin()); it != parents->end(); ++it) 26 26 { 27 27 - std::shared_ptr<Animal> parent = std::dynamic_pointer_cast<Animal>(*it); 27 27 + std::shared_ptr<Animal> parent = dynamic_pointer_cast<Animal>(*it); 28 28 if (parent->getAge() < 0) continue; 29 29 double distSqr = animal->distanceToSqr(parent); 30 30 if (distSqr > closestDistSqr) continue;

+1 -1

Minecraft.World/FurnaceMenu.cpp

··· 18 18 19 19 addSlot(new Slot(furnace, 0, 52 + 4, 13 + 4)); 20 20 addSlot(new Slot(furnace, 1, 52 + 4, 49 + 4)); 21 21 - addSlot(new FurnaceResultSlot( std::dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), furnace, 2, 112 + 4, 31 + 4)); 21 21 + addSlot(new FurnaceResultSlot( dynamic_pointer_cast<Player>( inventory->player->shared_from_this() ), furnace, 2, 112 + 4, 31 + 4)); 22 22 23 23 for (int y = 0; y < 3; y++) 24 24 {

+2 -2

Minecraft.World/FurnaceTile.cpp

··· 112 112 { 113 113 return true; 114 114 } 115 115 - std::shared_ptr<FurnaceTileEntity> furnace = std::dynamic_pointer_cast<FurnaceTileEntity>( level->getTileEntity(x, y, z) ); 115 115 + std::shared_ptr<FurnaceTileEntity> furnace = dynamic_pointer_cast<FurnaceTileEntity>( level->getTileEntity(x, y, z) ); 116 116 if (furnace != NULL ) player->openFurnace(furnace); 117 117 return true; 118 118 } ··· 154 154 { 155 155 if (!noDrop) 156 156 { 157 157 - std::shared_ptr<Container> container = std::dynamic_pointer_cast<FurnaceTileEntity>( level->getTileEntity(x, y, z) ); 157 157 + std::shared_ptr<Container> container = dynamic_pointer_cast<FurnaceTileEntity>( level->getTileEntity(x, y, z) ); 158 158 if( container != NULL ) 159 159 { 160 160 for (unsigned int i = 0; i < container->getContainerSize(); i++)

+2 -2

Minecraft.World/Ghast.cpp

··· 49 49 { 50 50 if (source->getMsgId() == ChatPacket::e_ChatDeathFireball) 51 51 { 52 52 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( source->getEntity() ); 52 52 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( source->getEntity() ); 53 53 if (player != NULL) 54 54 { 55 55 // reflected fireball, kill the ghast ··· 151 151 { 152 152 // 4J - change brought forward from 1.2.3 153 153 level->levelEvent(nullptr, LevelEvent::SOUND_GHAST_FIREBALL, (int) x, (int) y, (int) z, 0); 154 154 - std::shared_ptr<Fireball> ie = std::shared_ptr<Fireball>( new Fireball(level, std::dynamic_pointer_cast<Mob>( shared_from_this() ), xdd, ydd, zdd) ); 154 154 + std::shared_ptr<Fireball> ie = std::shared_ptr<Fireball>( new Fireball(level, dynamic_pointer_cast<Mob>( shared_from_this() ), xdd, ydd, zdd) ); 155 155 double d = 4; 156 156 Vec3 *v = getViewVector(1); 157 157 ie->x = x + v->x * d;

+4 -4

Minecraft.World/HangingEntity.cpp

··· 156 156 for (AUTO_VAR(it, entities->begin()); it != itEnd; it++) 157 157 { 158 158 std::shared_ptr<Entity> e = (*it); 159 159 - if(std::dynamic_pointer_cast<HangingEntity>(e) != NULL) 159 159 + if(dynamic_pointer_cast<HangingEntity>(e) != NULL) 160 160 { 161 161 return false; 162 162 } ··· 176 176 { 177 177 if(source->GetType()==eTYPE_PLAYER) 178 178 { 179 179 - return hurt(DamageSource::playerAttack(std::dynamic_pointer_cast<Player>( source)), 0); 179 179 + return hurt(DamageSource::playerAttack(dynamic_pointer_cast<Player>( source)), 0); 180 180 } 181 181 return false; 182 182 } ··· 189 189 { 190 190 std::shared_ptr<Entity> sourceEntity = source->getDirectEntity(); 191 191 192 192 - if (std::dynamic_pointer_cast<Player>(sourceEntity) != NULL && !std::dynamic_pointer_cast<Player>(sourceEntity)->isAllowedToHurtEntity(shared_from_this()) ) 192 192 + if (dynamic_pointer_cast<Player>(sourceEntity) != NULL && !dynamic_pointer_cast<Player>(sourceEntity)->isAllowedToHurtEntity(shared_from_this()) ) 193 193 { 194 194 return false; 195 195 } ··· 202 202 std::shared_ptr<Entity> e = source->getEntity(); 203 203 if (e!=NULL && ((e->GetType() & eTYPE_PLAYER)!=0) ) // check if it's serverplayer or player 204 204 { 205 205 - player = std::dynamic_pointer_cast<Player>( e ); 205 205 + player = dynamic_pointer_cast<Player>( e ); 206 206 } 207 207 208 208 if (player != NULL && player->abilities.instabuild)

+2 -2

Minecraft.World/HangingEntityItem.cpp

··· 72 72 std::shared_ptr<Painting> painting = std::shared_ptr<Painting>(new Painting(level, x, y, z, dir)); 73 73 painting->PaintingPostConstructor(dir); 74 74 75 75 - return std::dynamic_pointer_cast<HangingEntity> (painting); 75 75 + return dynamic_pointer_cast<HangingEntity> (painting); 76 76 } 77 77 else if (eType == eTYPE_ITEM_FRAME) 78 78 { 79 79 std::shared_ptr<ItemFrame> itemFrame = std::shared_ptr<ItemFrame>(new ItemFrame(level, x, y, z, dir)); 80 80 81 81 - return std::dynamic_pointer_cast<HangingEntity> (itemFrame); 81 81 + return dynamic_pointer_cast<HangingEntity> (itemFrame); 82 82 } 83 83 else 84 84 {

+1 -1

Minecraft.World/HurtByTargetGoal.cpp

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

+1 -1

Minecraft.World/IndirectEntityDamageSource.cpp

··· 36 36 type = owner->GetType(); 37 37 if(type == eTYPE_SERVERPLAYER) 38 38 { 39 39 - std::shared_ptr<Player> sourcePlayer = std::dynamic_pointer_cast<Player>(owner); 39 39 + std::shared_ptr<Player> sourcePlayer = dynamic_pointer_cast<Player>(owner); 40 40 if(sourcePlayer != NULL) additional = sourcePlayer->name; 41 41 } 42 42 }

+1 -1

Minecraft.World/Inventory.cpp

··· 606 606 { 607 607 if (armor[i] != NULL && dynamic_cast<ArmorItem *>( armor[i]->getItem() ) != NULL ) 608 608 { 609 609 - armor[i]->hurt(dmg, std::dynamic_pointer_cast<Mob>( player->shared_from_this() ) ); 609 609 + armor[i]->hurt(dmg, dynamic_pointer_cast<Mob>( player->shared_from_this() ) ); 610 610 if (armor[i]->count == 0) 611 611 { 612 612 armor[i] = nullptr;

+2 -2

Minecraft.World/ItemEntity.cpp

··· 137 137 vector<std::shared_ptr<Entity> > *neighbours = level->getEntitiesOfClass(typeid(*this), bb->grow(0.5, 0, 0.5)); 138 138 for(AUTO_VAR(it, neighbours->begin()); it != neighbours->end(); ++it) 139 139 { 140 140 - std::shared_ptr<ItemEntity> entity = std::dynamic_pointer_cast<ItemEntity>(*it); 140 140 + std::shared_ptr<ItemEntity> entity = dynamic_pointer_cast<ItemEntity>(*it); 141 141 merge(entity); 142 142 } 143 143 delete neighbours; ··· 154 154 if (targetItem->hasTag() ^ myItem->hasTag()) return false; 155 155 if (targetItem->hasTag() && !targetItem->getTag()->equals(myItem->getTag())) return false; 156 156 if (targetItem->getItem()->isStackedByData() && targetItem->getAuxValue() != myItem->getAuxValue()) return false; 157 157 - if (targetItem->count < myItem->count) return target->merge(std::dynamic_pointer_cast<ItemEntity>(shared_from_this())); 157 157 + if (targetItem->count < myItem->count) return target->merge(dynamic_pointer_cast<ItemEntity>(shared_from_this())); 158 158 if (targetItem->count + myItem->count > targetItem->getMaxStackSize()) return false; 159 159 160 160 targetItem->count += myItem->count;

+1 -1

Minecraft.World/ItemFrame.cpp

··· 66 66 item = item->copy(); 67 67 item->count = 1; 68 68 69 69 - item->setFramed(std::dynamic_pointer_cast<ItemFrame>( shared_from_this() )); 69 69 + item->setFramed(dynamic_pointer_cast<ItemFrame>( shared_from_this() )); 70 70 } 71 71 getEntityData()->set(DATA_ITEM, item); 72 72 getEntityData()->markDirty(DATA_ITEM);

+1 -1

Minecraft.World/ItemInstance.cpp

··· 216 216 return; 217 217 } 218 218 219 219 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(owner); 219 219 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(owner); 220 220 if (i > 0 && player != NULL) 221 221 { 222 222 int enchanted = EnchantmentHelper::getDigDurability(player->inventory);

+1 -1

Minecraft.World/KillCommand.cpp

··· 11 11 12 12 void KillCommand::execute(std::shared_ptr<CommandSender> source, byteArray commandData) 13 13 { 14 14 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(source); 14 14 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(source); 15 15 16 16 player->hurt(DamageSource::outOfWorld, 1000); 17 17

+11 -11

Minecraft.World/Level.cpp

··· 568 568 if( !this->levelData->useNewSeaLevel() ) seaLevel = Level::genDepth / 2; // 4J added - sea level is one unit lower since 1.8.2, maintain older height for old levels 569 569 this->savedDataStorage = new SavedDataStorage(levelStorage.get()); 570 570 571 571 - std::shared_ptr<Villages> savedVillages = std::dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID)); 571 571 + std::shared_ptr<Villages> savedVillages = dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID)); 572 572 if (savedVillages == NULL) 573 573 { 574 574 villages = std::shared_ptr<Villages>(new Villages(this)); ··· 597 597 if( !this->levelData->useNewSeaLevel() ) seaLevel = Level::genDepth / 2; // 4J added - sea level is one unit lower since 1.8.2, maintain older height for old levels 598 598 this->savedDataStorage = new SavedDataStorage( levelStorage.get() ); 599 599 600 600 - std::shared_ptr<Villages> savedVillages = std::dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID)); 600 600 + std::shared_ptr<Villages> savedVillages = dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID)); 601 601 if (savedVillages == NULL) 602 602 { 603 603 villages = std::shared_ptr<Villages>(new Villages(this)); ··· 636 636 this->levelStorage = levelStorage;//std::shared_ptr<LevelStorage>(levelStorage); 637 637 this->savedDataStorage = new SavedDataStorage(levelStorage.get()); 638 638 639 639 - std::shared_ptr<Villages> savedVillages = std::dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID)); 639 639 + std::shared_ptr<Villages> savedVillages = dynamic_pointer_cast<Villages>(savedDataStorage->get(typeid(Villages), Villages::VILLAGE_FILE_ID)); 640 640 if (savedVillages == NULL) 641 641 { 642 642 villages = std::shared_ptr<Villages>(new Villages(this)); ··· 1667 1667 } 1668 1668 1669 1669 bool forced = false; 1670 1670 - if (std::dynamic_pointer_cast<Player>( e ) != NULL) 1670 1670 + if (dynamic_pointer_cast<Player>( e ) != NULL) 1671 1671 { 1672 1672 forced = true; 1673 1673 } 1674 1674 1675 1675 if (forced || hasChunk(xc, zc)) 1676 1676 { 1677 1677 - if (std::dynamic_pointer_cast<Player>( e ) != NULL) 1677 1677 + if (dynamic_pointer_cast<Player>( e ) != NULL) 1678 1678 { 1679 1679 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(e); 1679 1679 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e); 1680 1680 1681 1681 // 4J Stu - Added so we don't continually add the player to the players list while they are dead 1682 1682 if( find( players.begin(), players.end(), e ) == players.end() ) ··· 1744 1744 e->ride(nullptr); 1745 1745 } 1746 1746 e->remove(); 1747 1747 - if (std::dynamic_pointer_cast<Player>( e ) != NULL) 1747 1747 + if (dynamic_pointer_cast<Player>( e ) != NULL) 1748 1748 { 1749 1749 vector<std::shared_ptr<Player> >::iterator it = players.begin(); 1750 1750 vector<std::shared_ptr<Player> >::iterator itEnd = players.end(); 1751 1751 - while( it != itEnd && *it != std::dynamic_pointer_cast<Player>(e) ) 1751 1751 + while( it != itEnd && *it != dynamic_pointer_cast<Player>(e) ) 1752 1752 it++; 1753 1753 1754 1754 if( it != itEnd ) ··· 1766 1766 { 1767 1767 e->remove(); 1768 1768 1769 1769 - if (std::dynamic_pointer_cast<Player>( e ) != NULL) 1769 1769 + if (dynamic_pointer_cast<Player>( e ) != NULL) 1770 1770 { 1771 1771 vector<std::shared_ptr<Player> >::iterator it = players.begin(); 1772 1772 vector<std::shared_ptr<Player> >::iterator itEnd = players.end(); 1773 1773 - while( it != itEnd && *it != std::dynamic_pointer_cast<Player>(e) ) 1773 1773 + while( it != itEnd && *it != dynamic_pointer_cast<Player>(e) ) 1774 1774 it++; 1775 1775 1776 1776 if( it != itEnd ) ··· 2286 2286 if (!e->removed) 2287 2287 { 2288 2288 #ifndef _FINAL_BUILD 2289 2289 - if(!( app.DebugSettingsOn() && app.GetMobsDontTickEnabled() && (std::dynamic_pointer_cast<Mob>(e) != NULL) && (std::dynamic_pointer_cast<Player>(e) == NULL))) 2289 2289 + if(!( app.DebugSettingsOn() && app.GetMobsDontTickEnabled() && (dynamic_pointer_cast<Mob>(e) != NULL) && (dynamic_pointer_cast<Player>(e) == NULL))) 2290 2290 #endif 2291 2291 { 2292 2292 tick(e);

+4 -4

Minecraft.World/LevelChunk.cpp

··· 1639 1639 1640 1640 bool isAssignableFrom = false; 1641 1641 // Some special cases where the base class is a general type that our class may be derived from, otherwise do a direct comparison of type_info 1642 1642 - if( ec == typeid(Player) ) { if( std::dynamic_pointer_cast<Player>(e) != NULL ) isAssignableFrom = true; } 1643 1643 - else if ( ec == typeid(Mob) ) { if( std::dynamic_pointer_cast<Mob>(e) != NULL ) isAssignableFrom = true; } 1644 1644 - else if ( ec == typeid(Monster) ) { if( std::dynamic_pointer_cast<Monster>(e) != NULL ) isAssignableFrom = true; } 1645 1645 - else if ( ec == typeid(Zombie) ) { if( std::dynamic_pointer_cast<Zombie>(e) != NULL ) isAssignableFrom = true; } 1642 1642 + if( ec == typeid(Player) ) { if( dynamic_pointer_cast<Player>(e) != NULL ) isAssignableFrom = true; } 1643 1643 + else if ( ec == typeid(Mob) ) { if( dynamic_pointer_cast<Mob>(e) != NULL ) isAssignableFrom = true; } 1644 1644 + else if ( ec == typeid(Monster) ) { if( dynamic_pointer_cast<Monster>(e) != NULL ) isAssignableFrom = true; } 1645 1645 + else if ( ec == typeid(Zombie) ) { if( dynamic_pointer_cast<Zombie>(e) != NULL ) isAssignableFrom = true; } 1646 1646 else if(e != NULL && ec == typeid(*(e.get())) ) isAssignableFrom = true; 1647 1647 if (isAssignableFrom && e->bb->intersects(bb)) es.push_back(e); 1648 1648 // 4J - note needs to be equivalent to baseClass.isAssignableFrom(e.getClass())

+1 -1

Minecraft.World/LookAtTradingPlayerGoal.cpp

··· 12 12 { 13 13 if (villager->isTrading()) 14 14 { 15 15 - lookAt = weak_ptr<Entity>(std::dynamic_pointer_cast<Entity>(villager->getTradingPlayer())); 15 15 + lookAt = weak_ptr<Entity>(dynamic_pointer_cast<Entity>(villager->getTradingPlayer())); 16 16 return true; 17 17 } 18 18 return false;

+1 -1

Minecraft.World/LookControl.cpp

··· 16 16 void LookControl::setLookAt(std::shared_ptr<Entity> target, float yMax, float xMax) 17 17 { 18 18 this->wantedX = target->x; 19 19 - std::shared_ptr<Mob> targetMob = std::dynamic_pointer_cast<Mob>(target); 19 19 + std::shared_ptr<Mob> targetMob = dynamic_pointer_cast<Mob>(target); 20 20 if (targetMob != NULL) this->wantedY = target->y + targetMob->getHeadHeight(); 21 21 else this->wantedY = (target->bb->y0 + target->bb->y1) / 2; 22 22 this->wantedZ = target->z;

+1 -1

Minecraft.World/MakeLoveGoal.cpp

··· 32 32 std::shared_ptr<Entity> mate = level->getClosestEntityOfClass(typeid(Villager), villager->bb->grow(8, 3, 8), villager->shared_from_this()); 33 33 if (mate == NULL) return false; 34 34 35 35 - partner = weak_ptr<Villager>(std::dynamic_pointer_cast<Villager>(mate)); 35 35 + partner = weak_ptr<Villager>(dynamic_pointer_cast<Villager>(mate)); 36 36 if (partner.lock()->getAge() != 0) return false; 37 37 38 38 return true;

+4 -4

Minecraft.World/MapItem.cpp

··· 22 22 std::shared_ptr<MapItemSavedData> MapItem::getSavedData(short idNum, Level *level) 23 23 { 24 24 std::wstring id = wstring( L"map_" ) + _toString(idNum); 25 25 - std::shared_ptr<MapItemSavedData> mapItemSavedData = std::dynamic_pointer_cast<MapItemSavedData>(level->getSavedData(typeid(MapItemSavedData), id)); 25 25 + std::shared_ptr<MapItemSavedData> mapItemSavedData = dynamic_pointer_cast<MapItemSavedData>(level->getSavedData(typeid(MapItemSavedData), id)); 26 26 27 27 if (mapItemSavedData == NULL) 28 28 { ··· 45 45 MemSect(31); 46 46 std::wstring id = wstring( L"map_" ) + _toString(itemInstance->getAuxValue() ); 47 47 MemSect(0); 48 48 - std::shared_ptr<MapItemSavedData> mapItemSavedData = std::dynamic_pointer_cast<MapItemSavedData>( level->getSavedData(typeid(MapItemSavedData), id ) ); 48 48 + std::shared_ptr<MapItemSavedData> mapItemSavedData = dynamic_pointer_cast<MapItemSavedData>( level->getSavedData(typeid(MapItemSavedData), id ) ); 49 49 50 50 bool newData = false; 51 51 if (mapItemSavedData == NULL) ··· 264 264 if (level->isClientSide) return; 265 265 266 266 std::shared_ptr<MapItemSavedData> data = getSavedData(itemInstance, level); 267 267 - if (std::dynamic_pointer_cast<Player>(owner) != NULL) 267 267 + if (dynamic_pointer_cast<Player>(owner) != NULL) 268 268 { 269 269 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(owner); 269 269 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(owner); 270 270 271 271 // 4J Stu - If the player has a map that belongs to another player, then merge the data over and change this map id to the owners id 272 272 int ownersAuxValue = level->getAuxValueForMap(player->getXuid(), data->dimension, data->x, data->z, data->scale);

+1 -1

Minecraft.World/MapItemSavedData.cpp

··· 125 125 } 126 126 delete data.data; 127 127 } 128 128 - std::shared_ptr<ServerPlayer> servPlayer = std::dynamic_pointer_cast<ServerPlayer>(player); 128 128 + std::shared_ptr<ServerPlayer> servPlayer = dynamic_pointer_cast<ServerPlayer>(player); 129 129 for (int d = 0; d < 10; d++) 130 130 { 131 131 int column = (tick * 11) % (MapItem::IMAGE_WIDTH);

+1 -1

Minecraft.World/MerchantMenu.cpp

··· 10 10 trader = merchant; 11 11 this->level = level; 12 12 13 13 - tradeContainer = std::shared_ptr<MerchantContainer>( new MerchantContainer(std::dynamic_pointer_cast<Player>(inventory->player->shared_from_this()), merchant) ); 13 13 + tradeContainer = std::shared_ptr<MerchantContainer>( new MerchantContainer(dynamic_pointer_cast<Player>(inventory->player->shared_from_this()), merchant) ); 14 14 addSlot(new Slot(tradeContainer, PAYMENT1_SLOT, SELLSLOT1_X, ROW2_Y)); 15 15 addSlot(new Slot(tradeContainer, PAYMENT2_SLOT, SELLSLOT2_X, ROW2_Y)); 16 16 addSlot(new MerchantResultSlot(inventory->player, merchant, tradeContainer, RESULT_SLOT, BUYSLOT_X, ROW2_Y));

+1 -1

Minecraft.World/MerchantResultSlot.cpp

··· 33 33 34 34 void MerchantResultSlot::checkTakeAchievements(std::shared_ptr<ItemInstance> carried) 35 35 { 36 36 - carried->onCraftedBy(player->level, std::dynamic_pointer_cast<Player>(player->shared_from_this()), removeCount); 36 36 + carried->onCraftedBy(player->level, dynamic_pointer_cast<Player>(player->shared_from_this()), removeCount); 37 37 removeCount = 0; 38 38 } 39 39

+1 -1

Minecraft.World/MineShaftPieces.cpp

··· 440 440 { 441 441 hasPlacedSpider = true; 442 442 level->setTile(x, y, newZ, Tile::mobSpawner_Id); 443 443 - std::shared_ptr<MobSpawnerTileEntity> entity = std::dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, newZ) ); 443 443 + std::shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, newZ) ); 444 444 if (entity != NULL) entity->setEntityId(L"CaveSpider"); 445 445 } 446 446 }

+9 -9

Minecraft.World/Minecart.cpp

··· 187 187 { 188 188 std::shared_ptr<Entity> attacker = source->getDirectEntity(); 189 189 190 190 - if (std::dynamic_pointer_cast<Player>(attacker) != NULL && 191 191 - !std::dynamic_pointer_cast<Player>(attacker)->isAllowedToHurtEntity( shared_from_this() )) 190 190 + if (dynamic_pointer_cast<Player>(attacker) != NULL && 191 191 + !dynamic_pointer_cast<Player>(attacker)->isAllowedToHurtEntity( shared_from_this() )) 192 192 return false; 193 193 } 194 194 ··· 202 202 if( rider.lock() != NULL && rider.lock() == source->getEntity() ) hurtDamage += 1; 203 203 204 204 // 4J Stu - Brought froward from 12w36 to fix #46611 - TU5: Gameplay: Minecarts and boat requires more hits than one to be destroyed in creative mode 205 205 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(source->getEntity()); 205 205 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(source->getEntity()); 206 206 if (player != NULL && player->abilities.instabuild) this->setDamage(100); 207 207 208 208 this->setDamage(getDamage() + (hurtDamage * 10)); ··· 215 215 spawnAtLocation(Item::minecart->id, 1, 0); 216 216 if (type == Minecart::CHEST) 217 217 { 218 218 - std::shared_ptr<Container> container = std::dynamic_pointer_cast<Container>( shared_from_this() ); 218 218 + std::shared_ptr<Container> container = dynamic_pointer_cast<Container>( shared_from_this() ); 219 219 for (unsigned int i = 0; i < container->getContainerSize(); i++) 220 220 { 221 221 std::shared_ptr<ItemInstance> item = container->getItem(i); ··· 678 678 std::shared_ptr<Entity> e = (*it); //entities->at(i); 679 679 if (e != rider.lock() && e->isPushable() && e->GetType() == eTYPE_MINECART) 680 680 { 681 681 - std::shared_ptr<Minecart> cart = std::dynamic_pointer_cast<Minecart>(e); 681 681 + std::shared_ptr<Minecart> cart = dynamic_pointer_cast<Minecart>(e); 682 682 cart->m_bHasPushedCartThisTick = false; 683 683 cart->push(shared_from_this()); 684 684 ··· 905 905 if (level->isClientSide) return; 906 906 907 907 if (e == rider.lock()) return; 908 908 - if (( std::dynamic_pointer_cast<Mob>(e)!=NULL) && std::dynamic_pointer_cast<Player>(e)==NULL && std::dynamic_pointer_cast<VillagerGolem>(e) == NULL && type == Minecart::RIDEABLE && xd * xd + zd * zd > 0.01) 908 908 + if (( dynamic_pointer_cast<Mob>(e)!=NULL) && dynamic_pointer_cast<Player>(e)==NULL && dynamic_pointer_cast<VillagerGolem>(e) == NULL && type == Minecart::RIDEABLE && xd * xd + zd * zd > 0.01) 909 909 { 910 910 if (rider.lock() == NULL && e->riding == NULL) 911 911 { ··· 954 954 double xdd = (e->xd + xd); 955 955 double zdd = (e->zd + zd); 956 956 957 957 - std::shared_ptr<Minecart> cart = std::dynamic_pointer_cast<Minecart>(e); 957 957 + std::shared_ptr<Minecart> cart = dynamic_pointer_cast<Minecart>(e); 958 958 if (cart != NULL && cart->type == Minecart::FURNACE && type != Minecart::FURNACE) 959 959 { 960 960 xd *= 0.2f; ··· 1077 1077 { 1078 1078 if (type == Minecart::RIDEABLE) 1079 1079 { 1080 1080 - if (rider.lock() != NULL && std::dynamic_pointer_cast<Player>(rider.lock())!=NULL && rider.lock() != player) return true; 1080 1080 + if (rider.lock() != NULL && dynamic_pointer_cast<Player>(rider.lock())!=NULL && rider.lock() != player) return true; 1081 1081 if (!level->isClientSide) 1082 1082 { 1083 1083 // 4J HEG - Fixed issue with player not being able to dismount minecart (issue #4455) ··· 1089 1089 if ( player->isAllowedToInteract(shared_from_this()) ) 1090 1090 { 1091 1091 if (!level->isClientSide) 1092 1092 - player->openContainer( std::dynamic_pointer_cast<Container>( shared_from_this() ) ); 1092 1092 + player->openContainer( dynamic_pointer_cast<Container>( shared_from_this() ) ); 1093 1093 } 1094 1094 else 1095 1095 {

+16 -16

Minecraft.World/Mob.cpp

··· 205 205 206 206 void Mob::setLastHurtMob(std::shared_ptr<Entity> target) 207 207 { 208 208 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(target); 208 208 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(target); 209 209 if (mob != NULL) lastHurtMob = mob; 210 210 } 211 211 ··· 661 661 if ( source->isFire() && hasEffect(MobEffect::fireResistance) ) 662 662 { 663 663 // 4J-JEV, for new achievement Stayin'Frosty, TODO merge with Java version. 664 664 - std::shared_ptr<Player> plr = std::dynamic_pointer_cast<Player>(shared_from_this()); 664 664 + std::shared_ptr<Player> plr = dynamic_pointer_cast<Player>(shared_from_this()); 665 665 if ( plr != NULL && source == DamageSource::lava ) // Only award when in lava (not any fire). 666 666 { 667 667 plr->awardStat(GenericStats::stayinFrosty(),GenericStats::param_stayinFrosty()); ··· 693 693 std::shared_ptr<Entity> sourceEntity = source->getEntity(); 694 694 if (sourceEntity != NULL) 695 695 { 696 696 - if (std::dynamic_pointer_cast<Mob>(sourceEntity) != NULL) { 697 697 - setLastHurtByMob(std::dynamic_pointer_cast<Mob>(sourceEntity)); 696 696 + if (dynamic_pointer_cast<Mob>(sourceEntity) != NULL) { 697 697 + setLastHurtByMob(dynamic_pointer_cast<Mob>(sourceEntity)); 698 698 699 699 } 700 700 - if (std::dynamic_pointer_cast<Player>(sourceEntity) != NULL) 700 700 + if (dynamic_pointer_cast<Player>(sourceEntity) != NULL) 701 701 { 702 702 lastHurtByPlayerTime = PLAYER_HURT_EXPERIENCE_TIME; 703 703 - lastHurtByPlayer = std::dynamic_pointer_cast<Player>(sourceEntity); 703 703 + lastHurtByPlayer = dynamic_pointer_cast<Player>(sourceEntity); 704 704 } 705 705 - else if (std::dynamic_pointer_cast<Wolf>(sourceEntity)) 705 705 + else if (dynamic_pointer_cast<Wolf>(sourceEntity)) 706 706 { 707 707 - std::shared_ptr<Wolf> w = std::dynamic_pointer_cast<Wolf>(sourceEntity); 707 707 + std::shared_ptr<Wolf> w = dynamic_pointer_cast<Wolf>(sourceEntity); 708 708 if (w->isTame()) 709 709 { 710 710 lastHurtByPlayerTime = PLAYER_HURT_EXPERIENCE_TIME; ··· 856 856 std::shared_ptr<Entity> sourceEntity = source->getEntity(); 857 857 if (deathScore >= 0 && sourceEntity != NULL) sourceEntity->awardKillScore(shared_from_this(), deathScore); 858 858 859 859 - if (sourceEntity != NULL) sourceEntity->killed( std::dynamic_pointer_cast<Mob>( shared_from_this() ) ); 859 859 + if (sourceEntity != NULL) sourceEntity->killed( dynamic_pointer_cast<Mob>( shared_from_this() ) ); 860 860 861 861 dead = true; 862 862 863 863 if (!level->isClientSide) 864 864 { 865 865 int playerBonus = 0; 866 866 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(sourceEntity); 866 866 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(sourceEntity); 867 867 if (player != NULL) 868 868 { 869 869 playerBonus = EnchantmentHelper::getKillingLootBonus(player->inventory); ··· 884 884 // 4J-JEV, hook for Durango mobKill event. 885 885 if (player != NULL) 886 886 { 887 887 - player->awardStat(GenericStats::killMob(),GenericStats::param_mobKill(player, std::dynamic_pointer_cast<Mob>(shared_from_this()), source)); 887 887 + player->awardStat(GenericStats::killMob(),GenericStats::param_mobKill(player, dynamic_pointer_cast<Mob>(shared_from_this()), source)); 888 888 } 889 889 } 890 890 ··· 953 953 void Mob::travel(float xa, float ya) 954 954 { 955 955 #ifdef __PSVITA__ 956 956 - // AP - std::dynamic_pointer_cast is a non-trivial call 956 956 + // AP - dynamic_pointer_cast is a non-trivial call 957 957 Player *thisPlayer = NULL; 958 958 if( (GetType() & eTYPE_PLAYER) == eTYPE_PLAYER ) 959 959 { 960 960 thisPlayer = (Player*) this; 961 961 } 962 962 #else 963 963 - std::shared_ptr<Player> thisPlayer = std::dynamic_pointer_cast<Player>(shared_from_this()); 963 963 + std::shared_ptr<Player> thisPlayer = dynamic_pointer_cast<Player>(shared_from_this()); 964 964 #endif 965 965 if (isInWater() && !(thisPlayer && thisPlayer->abilities.flying) ) 966 966 { ··· 1038 1038 if (zd > max) zd = max; 1039 1039 this->fallDistance = 0; 1040 1040 if (yd < -0.15) yd = -0.15; 1041 1041 - bool playerSneaking = isSneaking() && std::dynamic_pointer_cast<Player>(shared_from_this()) != NULL; 1041 1041 + bool playerSneaking = isSneaking() && dynamic_pointer_cast<Player>(shared_from_this()) != NULL; 1042 1042 if (playerSneaking && yd < 0) yd = 0; 1043 1043 } 1044 1044 ··· 1455 1455 double yd; 1456 1456 double zd = e->z - z; 1457 1457 1458 1458 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(e); 1458 1458 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e); 1459 1459 if(mob != NULL) 1460 1460 { 1461 1461 yd = (y + getHeadHeight()) - (mob->y + mob->getHeadHeight()); ··· 1657 1657 { 1658 1658 MobEffectInstance *effect = it->second; 1659 1659 removed = false; 1660 1660 - if (!effect->tick(std::dynamic_pointer_cast<Mob>(shared_from_this()))) 1660 1660 + if (!effect->tick(dynamic_pointer_cast<Mob>(shared_from_this()))) 1661 1661 { 1662 1662 if (!level->isClientSide) 1663 1663 {

+2 -2

Minecraft.World/MobEffect.cpp

··· 104 104 mob->hurt(DamageSource::magic, 1); 105 105 } 106 106 } 107 107 - else if (id == hunger->id && std::dynamic_pointer_cast<Player>(mob) != NULL) 107 107 + else if (id == hunger->id && dynamic_pointer_cast<Player>(mob) != NULL) 108 108 { 109 109 // every tick, cause the same amount of exhaustion as when removing 110 110 // a block, times amplification 111 111 - std::dynamic_pointer_cast<Player>(mob)->causeFoodExhaustion(FoodConstants::EXHAUSTION_MINE * (amplification + 1)); 111 111 + dynamic_pointer_cast<Player>(mob)->causeFoodExhaustion(FoodConstants::EXHAUSTION_MINE * (amplification + 1)); 112 112 } 113 113 else if ((id == heal->id && !mob->isInvertedHealAndHarm()) || (id == harm->id && mob->isInvertedHealAndHarm())) 114 114 {

+7 -7

Minecraft.World/MobSpawner.cpp

··· 294 294 // { 295 295 MemSect(29); 296 296 //mob = type.mobClass.getConstructor(Level.class).newInstance(level); 297 297 - mob = std::dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(currentMobType->mobClass, level)); 297 297 + mob = dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(currentMobType->mobClass, level)); 298 298 MemSect(0); 299 299 // } 300 300 // catch (exception e) ··· 425 425 426 426 void MobSpawner::finalizeMobSettings(std::shared_ptr<Mob> mob, Level *level, float xx, float yy, float zz) 427 427 { 428 428 - if (std::dynamic_pointer_cast<Spider>( mob ) != NULL && level->random->nextInt(100) == 0) 428 428 + if (dynamic_pointer_cast<Spider>( mob ) != NULL && level->random->nextInt(100) == 0) 429 429 { 430 430 std::shared_ptr<Skeleton> skeleton = std::shared_ptr<Skeleton>( new Skeleton(level) ); 431 431 skeleton->moveTo(xx, yy, zz, mob->yRot, 0); 432 432 level->addEntity(skeleton); 433 433 skeleton->ride(mob); 434 434 } 435 435 - else if (std::dynamic_pointer_cast<Sheep >( mob ) != NULL) 435 435 + else if (dynamic_pointer_cast<Sheep >( mob ) != NULL) 436 436 { 437 437 - (std::dynamic_pointer_cast<Sheep>( mob ))->setColor(Sheep::getSheepColor(level->random)); 437 437 + (dynamic_pointer_cast<Sheep>( mob ))->setColor(Sheep::getSheepColor(level->random)); 438 438 } 439 439 - else if (std::dynamic_pointer_cast<Ozelot >( mob ) != NULL) 439 439 + else if (dynamic_pointer_cast<Ozelot >( mob ) != NULL) 440 440 { 441 441 if (level->random->nextInt(7) == 0) 442 442 { ··· 520 520 // { 521 521 //mob = classes[type].getConstructor(Level.class).newInstance(level); 522 522 // 4J - there was a classes array here which duplicated the bedEnemies array but have removed it 523 523 - mob = std::dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(bedEnemies[type], level )); 523 523 + mob = dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(bedEnemies[type], level )); 524 524 // } 525 525 // catch (exception e) 526 526 // { ··· 621 621 622 622 std::shared_ptr<Mob> mob; 623 623 //try { 624 624 - mob = std::dynamic_pointer_cast<Mob>( EntityIO::newByEnumType(type->mobClass, level ) ); 624 624 + mob = dynamic_pointer_cast<Mob>( EntityIO::newByEnumType(type->mobClass, level ) ); 625 625 //} catch (Exception e) { 626 626 // e.printStackTrace(); 627 627 // continue;

+2 -2

Minecraft.World/MobSpawnerTileEntity.cpp

··· 89 89 90 90 for (int c = 0; c < spawnCount; c++) 91 91 { 92 92 - std::shared_ptr<Mob> entity = std::dynamic_pointer_cast<Mob> (EntityIO::newEntity(entityId, level)); 92 92 + std::shared_ptr<Mob> entity = dynamic_pointer_cast<Mob> (EntityIO::newEntity(entityId, level)); 93 93 if (entity == NULL) return; 94 94 95 95 vector<std::shared_ptr<Entity> > *vecNearby = level->getEntitiesOfClass(typeid(*entity), AABB::newTemp(x, y, z, x + 1, y + 1, z + 1)->grow(8, 4, 8)); ··· 115 115 double xp = x + (level->random->nextDouble() - level->random->nextDouble()) * 4; 116 116 double yp = y + level->random->nextInt(3) - 1; 117 117 double zp = z + (level->random->nextDouble() - level->random->nextDouble()) * 4; 118 118 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>( entity ); 118 118 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>( entity ); 119 119 120 120 entity->moveTo(xp, yp, zp, level->random->nextFloat() * 360, 0); 121 121

+3 -3

Minecraft.World/Monster.cpp

··· 95 95 dmg -= (2 << getEffect(MobEffect::weakness)->getAmplifier()); 96 96 } 97 97 98 98 - DamageSource *damageSource = DamageSource::mobAttack(std::dynamic_pointer_cast<Mob>( shared_from_this() ) ); 98 98 + DamageSource *damageSource = DamageSource::mobAttack(dynamic_pointer_cast<Mob>( shared_from_this() ) ); 99 99 bool didHurt = target->hurt(damageSource, dmg); 100 100 delete damageSource; 101 101 102 102 if (didHurt) 103 103 { 104 104 - int fireAspect = EnchantmentHelper::getFireAspect(std::dynamic_pointer_cast<Mob>(shared_from_this())); 104 104 + int fireAspect = EnchantmentHelper::getFireAspect(dynamic_pointer_cast<Mob>(shared_from_this())); 105 105 if (fireAspect > 0) 106 106 { 107 107 target->setOnFire(fireAspect * 4); 108 108 } 109 109 110 110 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(target); 110 110 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(target); 111 111 if (mob != NULL) 112 112 { 113 113 ThornsEnchantment::doThornsAfterAttack(shared_from_this(), mob, random);

+2 -2

Minecraft.World/MonsterPlacerItem.cpp

··· 181 181 // 4J Stu - Force adding this as a tile update 182 182 level->setTile(x,y,z,0); 183 183 level->setTile(x,y,z,Tile::mobSpawner_Id); 184 184 - std::shared_ptr<MobSpawnerTileEntity> mste = std::dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x,y,z) ); 184 184 + std::shared_ptr<MobSpawnerTileEntity> mste = dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x,y,z) ); 185 185 if(mste != NULL) 186 186 { 187 187 mste->setEntityId( EntityIO::getEncodeId(itemInstance->getAuxValue()) ); ··· 267 267 { 268 268 newEntity = canSpawn(mobId, level, piResult); 269 269 270 270 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(newEntity); 270 270 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(newEntity); 271 271 if (mob) 272 272 { 273 273 newEntity->moveTo(x, y, z, Mth::wrapDegrees(level->random->nextFloat() * 360), 0);

+2 -2

Minecraft.World/MonsterRoomFeature.cpp

··· 84 84 if (count != 1) continue; 85 85 86 86 level->setTile(xc, yc, zc, Tile::chest_Id); 87 87 - std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity >( level->getTileEntity(xc, yc, zc) ); 87 87 + std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity >( level->getTileEntity(xc, yc, zc) ); 88 88 if (chest != NULL ) 89 89 { 90 90 for (int j = 0; j < 8; j++) ··· 100 100 101 101 102 102 level->setTile(x, y, z, Tile::mobSpawner_Id); 103 103 - std::shared_ptr<MobSpawnerTileEntity> entity = std::dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, z) ); 103 103 + std::shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, z) ); 104 104 if( entity != NULL ) 105 105 { 106 106 entity->setEntityId(randomEntityId(random));

+1 -1

Minecraft.World/MoveEntityPacket.cpp

··· 60 60 61 61 bool MoveEntityPacket::isInvalidatedBy(std::shared_ptr<Packet> packet) 62 62 { 63 63 - std::shared_ptr<MoveEntityPacket> target = std::dynamic_pointer_cast<MoveEntityPacket>(packet); 63 63 + std::shared_ptr<MoveEntityPacket> target = dynamic_pointer_cast<MoveEntityPacket>(packet); 64 64 return target != NULL && target->id == id; 65 65 } 66 66

+1 -1

Minecraft.World/MoveEntityPacketSmall.cpp

··· 67 67 68 68 bool MoveEntityPacketSmall::isInvalidatedBy(std::shared_ptr<Packet> packet) 69 69 { 70 70 - std::shared_ptr<MoveEntityPacketSmall> target = std::dynamic_pointer_cast<MoveEntityPacketSmall>(packet); 70 70 + std::shared_ptr<MoveEntityPacketSmall> target = dynamic_pointer_cast<MoveEntityPacketSmall>(packet); 71 71 return target != NULL && target->id == id; 72 72 } 73 73

+1 -1

Minecraft.World/MoveIndoorsGoal.cpp

··· 44 44 } 45 45 if (mob->distanceToSqr(_doorInfo->getIndoorX(), _doorInfo->y, _doorInfo->getIndoorZ()) > 16 * 16) 46 46 { 47 47 - 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)); 47 47 + 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)); 48 48 if (pos != NULL) mob->getNavigation()->moveTo(pos->x, pos->y, pos->z, 0.3f); 49 49 } 50 50 else mob->getNavigation()->moveTo(_doorInfo->getIndoorX() + 0.5, _doorInfo->getIndoorY(), _doorInfo->getIndoorZ() + 0.5, 0.3f);

+1 -1

Minecraft.World/MoveThroughVillageGoal.cpp

··· 46 46 mob->getNavigation()->setCanOpenDoors(oldCanOpenDoors); 47 47 if (path != NULL) return true; 48 48 49 49 - Vec3 *pos = RandomPos::getPosTowards(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7, Vec3::newTemp(_doorInfo->x, _doorInfo->y, _doorInfo->z)); 49 49 + Vec3 *pos = RandomPos::getPosTowards(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7, Vec3::newTemp(_doorInfo->x, _doorInfo->y, _doorInfo->z)); 50 50 if (pos == NULL) return false; 51 51 mob->getNavigation()->setCanOpenDoors(false); 52 52 delete path;

+1 -1

Minecraft.World/MoveTowardsRestrictionGoal.cpp

··· 19 19 { 20 20 if (mob->isWithinRestriction()) return false; 21 21 Pos *towards = mob->getRestrictCenter(); 22 22 - Vec3 *pos = RandomPos::getPosTowards(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(towards->x, towards->y, towards->z)); 22 22 + Vec3 *pos = RandomPos::getPosTowards(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 7, Vec3::newTemp(towards->x, towards->y, towards->z)); 23 23 if (pos == NULL) return false; 24 24 wantedX = pos->x; 25 25 wantedY = pos->y;

+1 -1

Minecraft.World/MoveTowardsTargetGoal.cpp

··· 19 19 target = weak_ptr<Mob>(mob->getTarget()); 20 20 if (target.lock() == NULL) return false; 21 21 if (target.lock()->distanceToSqr(mob->shared_from_this()) > within * within) return false; 22 22 - 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)); 22 22 + 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)); 23 23 if (pos == NULL) return false; 24 24 wantedX = pos->x; 25 25 wantedY = pos->y;

+3 -3

Minecraft.World/MusicTile.cpp

··· 12 12 { 13 13 app.DebugPrintf("-------- Neighbour changed type %d\n", type); 14 14 bool signal = level->hasNeighborSignal(x, y, z); 15 15 - std::shared_ptr<MusicTileEntity> mte = std::dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) ); 15 15 + std::shared_ptr<MusicTileEntity> mte = dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) ); 16 16 app.DebugPrintf("-------- Signal is %s, tile is currently %s\n",signal?"TRUE":"FALSE", mte->on?"ON":"OFF"); 17 17 if (mte != NULL && mte->on != signal) 18 18 { ··· 34 34 { 35 35 if (soundOnly) return false; 36 36 if (level->isClientSide) return true; 37 37 - std::shared_ptr<MusicTileEntity> mte = std::dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) ); 37 37 + std::shared_ptr<MusicTileEntity> mte = dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) ); 38 38 if (mte != NULL ) 39 39 { 40 40 mte->tune(); ··· 46 46 void MusicTile::attack(Level *level, int x, int y, int z, std::shared_ptr<Player> player) 47 47 { 48 48 if (level->isClientSide) return; 49 49 - std::shared_ptr<MusicTileEntity> mte = std::dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) ); 49 49 + std::shared_ptr<MusicTileEntity> mte = dynamic_pointer_cast<MusicTileEntity>( level->getTileEntity(x, y, z) ); 50 50 if( mte != NULL ) mte->playNote(level, x, y, z); 51 51 } 52 52

+1 -1

Minecraft.World/NearestAttackableTargetGoal.cpp

··· 52 52 std::sort(entities->begin(), entities->end(), *distComp); 53 53 for(AUTO_VAR(it, entities->begin()); it != entities->end(); ++it) 54 54 { 55 55 - std::shared_ptr<Mob> potTarget = std::dynamic_pointer_cast<Mob>(*it); 55 55 + std::shared_ptr<Mob> potTarget = dynamic_pointer_cast<Mob>(*it); 56 56 if (canAttack(potTarget, false)) 57 57 { 58 58 target = weak_ptr<Mob>(potTarget);

+1 -1

Minecraft.World/NetherBridgePieces.cpp

··· 757 757 { 758 758 hasPlacedMobSpawner = true; 759 759 level->setTile(x, y, z, Tile::mobSpawner_Id); 760 760 - std::shared_ptr<MobSpawnerTileEntity> entity = std::dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, z) ); 760 760 + std::shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, z) ); 761 761 if (entity != NULL) entity->setEntityId(L"Blaze"); 762 762 } 763 763 }

+1 -1

Minecraft.World/OcelotSitOnTileGoal.cpp

··· 107 107 108 108 if (tile == Tile::chest_Id) 109 109 { 110 110 - std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z)); 110 110 + std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity(x, y, z)); 111 111 112 112 if (chest->openCount < 1) 113 113 {

+1 -1

Minecraft.World/OfferFlowerGoal.cpp

··· 16 16 { 17 17 if (!golem->level->isDay()) return false; 18 18 if (golem->getRandom()->nextInt(8000) != 0) return false; 19 19 - villager = weak_ptr<Villager>(std::dynamic_pointer_cast<Villager>( golem->level->getClosestEntityOfClass(typeid(Villager), golem->bb->grow(6, 2, 6), golem->shared_from_this()) )); 19 19 + villager = weak_ptr<Villager>(dynamic_pointer_cast<Villager>( golem->level->getClosestEntityOfClass(typeid(Villager), golem->bb->grow(6, 2, 6), golem->shared_from_this()) )); 20 20 return villager.lock() != NULL; 21 21 } 22 22

+2 -2

Minecraft.World/Ozelot.cpp

··· 186 186 187 187 bool Ozelot::doHurtTarget(std::shared_ptr<Entity> target) 188 188 { 189 189 - return target->hurt(DamageSource::mobAttack(std::dynamic_pointer_cast<Mob>(shared_from_this())), 3); 189 189 + return target->hurt(DamageSource::mobAttack(dynamic_pointer_cast<Mob>(shared_from_this())), 3); 190 190 } 191 191 192 192 bool Ozelot::hurt(DamageSource *source, int dmg) ··· 280 280 if (animal == shared_from_this()) return false; 281 281 if (!isTame()) return false; 282 282 283 283 - std::shared_ptr<Ozelot> partner = std::dynamic_pointer_cast<Ozelot>(animal); 283 283 + std::shared_ptr<Ozelot> partner = dynamic_pointer_cast<Ozelot>(animal); 284 284 if (partner == NULL) return false; 285 285 if (!partner->isTame()) return false; 286 286

+1 -1

Minecraft.World/PanicGoal.cpp

··· 16 16 bool PanicGoal::canUse() 17 17 { 18 18 if (mob->getLastHurtByMob() == NULL) return false; 19 19 - Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 5, 4); 19 19 + Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 5, 4); 20 20 if (pos == NULL) return false; 21 21 posX = pos->x; 22 22 posY = pos->y;

+3 -3

Minecraft.World/Pig.cpp

··· 56 56 57 57 bool Pig::canBeControlledByRider() 58 58 { 59 59 - std::shared_ptr<ItemInstance> item = std::dynamic_pointer_cast<Player>(rider.lock())->getCarriedItem(); 59 59 + std::shared_ptr<ItemInstance> item = dynamic_pointer_cast<Player>(rider.lock())->getCarriedItem(); 60 60 61 61 return item != NULL && item->id == Item::carrotOnAStick_Id; 62 62 } ··· 162 162 void Pig::causeFallDamage(float distance) 163 163 { 164 164 Animal::causeFallDamage(distance); 165 165 - if (distance > 5 && std::dynamic_pointer_cast<Player>( rider.lock() ) != NULL) 165 165 + if (distance > 5 && dynamic_pointer_cast<Player>( rider.lock() ) != NULL) 166 166 { 167 167 - (std::dynamic_pointer_cast<Player>(rider.lock()))->awardStat(GenericStats::flyPig(),GenericStats::param_flyPig()); 167 167 + (dynamic_pointer_cast<Player>(rider.lock()))->awardStat(GenericStats::flyPig(),GenericStats::param_flyPig()); 168 168 } 169 169 } 170 170

+3 -3

Minecraft.World/PigZombie.cpp

··· 104 104 bool PigZombie::hurt(DamageSource *source, int dmg) 105 105 { 106 106 std::shared_ptr<Entity> sourceEntity = source->getEntity(); 107 107 - if (std::dynamic_pointer_cast<Player>(sourceEntity) != NULL) 107 107 + if (dynamic_pointer_cast<Player>(sourceEntity) != NULL) 108 108 { 109 109 vector<std::shared_ptr<Entity> > *nearby = level->getEntities( shared_from_this(), bb->grow(32, 32, 32)); 110 110 AUTO_VAR(itEnd, nearby->end()); 111 111 for (AUTO_VAR(it, nearby->begin()); it != itEnd; it++) 112 112 { 113 113 std::shared_ptr<Entity> e = *it; //nearby->at(i); 114 114 - if (std::dynamic_pointer_cast<PigZombie>(e) != NULL) 114 114 + if (dynamic_pointer_cast<PigZombie>(e) != NULL) 115 115 { 116 116 - std::shared_ptr<PigZombie> pigZombie = std::dynamic_pointer_cast<PigZombie>(e); 116 116 + std::shared_ptr<PigZombie> pigZombie = dynamic_pointer_cast<PigZombie>(e); 117 117 pigZombie->alert(sourceEntity); 118 118 } 119 119 }

+5 -5

Minecraft.World/PistonBaseTile.cpp

··· 126 126 127 127 void PistonBaseTile::setPlacedBy(Level *level, int x, int y, int z, std::shared_ptr<Mob> by) 128 128 { 129 129 - int targetData = getNewFacing(level, x, y, z, std::dynamic_pointer_cast<Player>(by) ); 129 129 + int targetData = getNewFacing(level, x, y, z, dynamic_pointer_cast<Player>(by) ); 130 130 level->setData(x, y, z, targetData); 131 131 if (!level->isClientSide && !ignoreUpdate()) 132 132 { ··· 250 250 { 251 251 PIXBeginNamedEvent(0,"Contract phase A\n"); 252 252 std::shared_ptr<TileEntity> prevTileEntity = level->getTileEntity(x + Facing::STEP_X[facing], y + Facing::STEP_Y[facing], z + Facing::STEP_Z[facing]); 253 253 - if (prevTileEntity != NULL && std::dynamic_pointer_cast<PistonPieceEntity>(prevTileEntity) != NULL) 253 253 + if (prevTileEntity != NULL && dynamic_pointer_cast<PistonPieceEntity>(prevTileEntity) != NULL) 254 254 { 255 255 - std::dynamic_pointer_cast<PistonPieceEntity>(prevTileEntity)->finalTick(); 255 255 + dynamic_pointer_cast<PistonPieceEntity>(prevTileEntity)->finalTick(); 256 256 } 257 257 258 258 stopSharingIfServer(level, x, y, z); // 4J added ··· 281 281 // so replace it with the real data, since it's probably 282 282 // this piston which is changing too fast 283 283 std::shared_ptr<TileEntity> tileEntity = level->getTileEntity(twoX, twoY, twoZ); 284 284 - if (tileEntity != NULL && std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL ) 284 284 + if (tileEntity != NULL && dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL ) 285 285 { 286 286 - std::shared_ptr<PistonPieceEntity> ppe = std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity); 286 286 + std::shared_ptr<PistonPieceEntity> ppe = dynamic_pointer_cast<PistonPieceEntity>(tileEntity); 287 287 288 288 if (ppe->getFacing() == facing && ppe->isExtending()) 289 289 {

+5 -5

Minecraft.World/PistonMovingPiece.cpp

··· 23 23 void PistonMovingPiece::onRemove(Level *level, int x, int y, int z, int id, int data) 24 24 { 25 25 std::shared_ptr<TileEntity> tileEntity = level->getTileEntity(x, y, z); 26 26 - if (tileEntity != NULL && std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL) 26 26 + if (tileEntity != NULL && dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL) 27 27 { 28 28 - std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity)->finalTick(); 28 28 + dynamic_pointer_cast<PistonPieceEntity>(tileEntity)->finalTick(); 29 29 } 30 30 else 31 31 { ··· 120 120 121 121 void PistonMovingPiece::updateShape(LevelSource *level, int x, int y, int z, int forceData, std::shared_ptr<TileEntity> forceEntity) // 4J added forceData, forceEntity param 122 122 { 123 123 - std::shared_ptr<PistonPieceEntity> entity = std::dynamic_pointer_cast<PistonPieceEntity>(forceEntity); 123 123 + std::shared_ptr<PistonPieceEntity> entity = dynamic_pointer_cast<PistonPieceEntity>(forceEntity); 124 124 if( entity == NULL ) entity = getEntity(level, x, y, z); 125 125 if (entity != NULL) 126 126 { ··· 191 191 std::shared_ptr<PistonPieceEntity> PistonMovingPiece::getEntity(LevelSource *level, int x, int y, int z) 192 192 { 193 193 std::shared_ptr<TileEntity> tileEntity = level->getTileEntity(x, y, z); 194 194 - if (tileEntity != NULL && std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL) 194 194 + if (tileEntity != NULL && dynamic_pointer_cast<PistonPieceEntity>(tileEntity) != NULL) 195 195 { 196 196 - return std::dynamic_pointer_cast<PistonPieceEntity>(tileEntity); 196 196 + return dynamic_pointer_cast<PistonPieceEntity>(tileEntity); 197 197 } 198 198 return nullptr; 199 199 }

+3 -3

Minecraft.World/PlayGoal.cpp

··· 32 32 { 33 33 std::shared_ptr<Entity> c = *it; 34 34 if (c.get() == mob) continue; 35 35 - std::shared_ptr<Villager> friendV = std::dynamic_pointer_cast<Villager>(c); 35 35 + std::shared_ptr<Villager> friendV = dynamic_pointer_cast<Villager>(c); 36 36 if (friendV->isChasing()) continue; 37 37 if (friendV->getAge() >= 0) continue; 38 38 double distSqr = friendV->distanceToSqr(mob->shared_from_this()); ··· 44 44 45 45 if (followFriend.lock() == NULL) 46 46 { 47 47 - Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 3); 47 47 + Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 3); 48 48 if (pos == NULL) return false; 49 49 } 50 50 return true; ··· 78 78 { 79 79 if (mob->getNavigation()->isDone()) 80 80 { 81 81 - Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 3); 81 81 + Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 16, 3); 82 82 if (pos == NULL) return; 83 83 mob->getNavigation()->moveTo(pos->x, pos->y, pos->z, speed); 84 84 }

+42 -42

Minecraft.World/Player.cpp

··· 214 214 { 215 215 if (useItem != NULL) 216 216 { 217 217 - useItem->releaseUsing(level, std::dynamic_pointer_cast<Player>( shared_from_this() ), useItemDuration); 217 217 + useItem->releaseUsing(level, dynamic_pointer_cast<Player>( shared_from_this() ), useItemDuration); 218 218 219 219 // 4J Stu - Fix for various bugs where an incorrect bow was displayed when it broke (#70859,#93972,#93974) 220 220 if (useItem->count == 0) ··· 312 312 313 313 if (!level->isClientSide) 314 314 { 315 315 - if (containerMenu != NULL && !containerMenu->stillValid( std::dynamic_pointer_cast<Player>( shared_from_this() ) )) 315 315 + if (containerMenu != NULL && !containerMenu->stillValid( dynamic_pointer_cast<Player>( shared_from_this() ) )) 316 316 { 317 317 closeContainer(); 318 318 containerMenu = inventoryMenu; ··· 355 355 356 356 if (!level->isClientSide) 357 357 { 358 358 - foodData.tick(std::dynamic_pointer_cast<Player>(shared_from_this())); 358 358 + foodData.tick(dynamic_pointer_cast<Player>(shared_from_this())); 359 359 } 360 360 361 361 // 4J Stu Debugging ··· 411 411 //this->drop( std::shared_ptr<ItemInstance>( new ItemInstance( Tile::fence, 64 ) ) ); 412 412 413 413 414 414 - //std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(Pig::_class->newInstance( level )); 414 414 + //std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(Pig::_class->newInstance( level )); 415 415 //mob->moveTo(x+1, y, z+1, level->random->nextFloat() * 360, 0); 416 416 //level->addEntity(mob); 417 417 418 418 // 4J : WESTY : Spawn some wolves to befriend! 419 419 /* 420 420 - std::shared_ptr<Mob> mob1 = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 420 420 + std::shared_ptr<Mob> mob1 = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 421 421 mob1->moveTo(x+1, y, z+1, level->random->nextFloat() * 360, 0); 422 422 level->addEntity(mob1); 423 423 424 424 - std::shared_ptr<Mob> mob2 = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 424 424 + std::shared_ptr<Mob> mob2 = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 425 425 mob2->moveTo(x+2, y, z+1, level->random->nextFloat() * 360, 0); 426 426 level->addEntity(mob2); 427 427 428 428 - std::shared_ptr<Mob> mob3 = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 428 428 + std::shared_ptr<Mob> mob3 = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 429 429 mob3->moveTo(x+1, y, z+2, level->random->nextFloat() * 360, 0); 430 430 level->addEntity(mob3); 431 431 432 432 - std::shared_ptr<Mob> mob4 = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 432 432 + std::shared_ptr<Mob> mob4 = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 433 433 mob4->moveTo(x+3, y, z+1, level->random->nextFloat() * 360, 0); 434 434 level->addEntity(mob4); 435 435 436 436 - std::shared_ptr<Mob> mob5 = std::dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 436 436 + std::shared_ptr<Mob> mob5 = dynamic_pointer_cast<Mob>(Wolf::_class->newInstance( level )); 437 437 mob5->moveTo(x+1, y, z+3, level->random->nextFloat() * 360, 0); 438 438 level->addEntity(mob5); 439 439 */ ··· 558 558 spawnEatParticles(useItem, 16); 559 559 560 560 int oldCount = useItem->count; 561 561 - std::shared_ptr<ItemInstance> itemInstance = useItem->useTimeDepleted(level, std::dynamic_pointer_cast<Player>(shared_from_this())); 561 561 + std::shared_ptr<ItemInstance> itemInstance = useItem->useTimeDepleted(level, dynamic_pointer_cast<Player>(shared_from_this())); 562 562 if (itemInstance != useItem || (itemInstance != NULL && itemInstance->count != oldCount)) 563 563 { 564 564 inventory->items[inventory->selected] = itemInstance; ··· 943 943 //xRot = preXRot; 944 944 //yRot = preYRot; 945 945 946 946 - std::shared_ptr<Pig> pig = std::dynamic_pointer_cast<Pig>(riding); 946 946 + std::shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(riding); 947 947 yBodyRot = pig->yBodyRot; 948 948 949 949 while (yBodyRot - yBodyRotO < -180) ··· 1056 1056 1057 1057 void Player::touch(std::shared_ptr<Entity> entity) 1058 1058 { 1059 1059 - entity->playerTouch( std::dynamic_pointer_cast<Player>( shared_from_this() ) ); 1059 1059 + entity->playerTouch( dynamic_pointer_cast<Player>( shared_from_this() ) ); 1060 1060 } 1061 1061 1062 1062 // 4J - Removed 1.0.1 ··· 1350 1350 if (dmg == 0) return false; 1351 1351 1352 1352 std::shared_ptr<Entity> attacker = source->getEntity(); 1353 1353 - if ( std::dynamic_pointer_cast<Arrow>( attacker ) != NULL ) 1353 1353 + if ( dynamic_pointer_cast<Arrow>( attacker ) != NULL ) 1354 1354 { 1355 1355 - if ((std::dynamic_pointer_cast<Arrow>(attacker))->owner != NULL) 1355 1355 + if ((dynamic_pointer_cast<Arrow>(attacker))->owner != NULL) 1356 1356 { 1357 1357 - attacker = (std::dynamic_pointer_cast<Arrow>(attacker))->owner; 1357 1357 + attacker = (dynamic_pointer_cast<Arrow>(attacker))->owner; 1358 1358 } 1359 1359 } 1360 1360 - if ( std::dynamic_pointer_cast<Mob>( attacker ) != NULL ) 1360 1360 + if ( dynamic_pointer_cast<Mob>( attacker ) != NULL ) 1361 1361 { 1362 1362 // aggreviate all pet wolves nearby 1363 1363 - directAllTameWolvesOnTarget(std::dynamic_pointer_cast<Mob>(attacker), false); 1363 1363 + directAllTameWolvesOnTarget(dynamic_pointer_cast<Mob>(attacker), false); 1364 1364 } 1365 1365 1366 1366 return this->Mob::hurt(source, dmg); ··· 1399 1399 { 1400 1400 1401 1401 // filter un-attackable mobs 1402 1402 - if ((std::dynamic_pointer_cast<Creeper>( target ) != NULL) || (std::dynamic_pointer_cast<Ghast>( target) != NULL)) 1402 1402 + if ((dynamic_pointer_cast<Creeper>( target ) != NULL) || (dynamic_pointer_cast<Ghast>( target) != NULL)) 1403 1403 { 1404 1404 return; 1405 1405 } 1406 1406 // never target wolves that has this player as owner 1407 1407 - if (std::dynamic_pointer_cast<Wolf>(target) != NULL) 1407 1407 + if (dynamic_pointer_cast<Wolf>(target) != NULL) 1408 1408 { 1409 1409 - std::shared_ptr<Wolf> wolfTarget = std::dynamic_pointer_cast<Wolf>(target); 1409 1409 + std::shared_ptr<Wolf> wolfTarget = dynamic_pointer_cast<Wolf>(target); 1410 1410 if (wolfTarget->isTame() && m_UUID.compare( wolfTarget->getOwnerUUID() ) == 0 ) 1411 1411 { 1412 1412 return; 1413 1413 } 1414 1414 } 1415 1415 - if ((std::dynamic_pointer_cast<Player>( target ) != NULL) && !isPlayerVersusPlayer()) 1415 1415 + if ((dynamic_pointer_cast<Player>( target ) != NULL) && !isPlayerVersusPlayer()) 1416 1416 { 1417 1417 // pvp is off 1418 1418 return; ··· 1424 1424 AUTO_VAR(itEnd, nearbyWolves->end()); 1425 1425 for (AUTO_VAR(it, nearbyWolves->begin()); it != itEnd; it++) 1426 1426 { 1427 1427 - std::shared_ptr<Wolf> wolf = std::dynamic_pointer_cast<Wolf>(*it);; 1427 1427 + std::shared_ptr<Wolf> wolf = dynamic_pointer_cast<Wolf>(*it);; 1428 1428 if (wolf->isTame() && wolf->getAttackTarget() == NULL && m_UUID.compare( wolf->getOwnerUUID() ) == 0) 1429 1429 { 1430 1430 if (!skipSitting || !wolf->isSitting()) ··· 1509 1509 1510 1510 bool Player::interact(std::shared_ptr<Entity> entity) 1511 1511 { 1512 1512 - if (entity->interact( std::dynamic_pointer_cast<Player>( shared_from_this() ) )) return true; 1512 1512 + if (entity->interact( dynamic_pointer_cast<Player>( shared_from_this() ) )) return true; 1513 1513 std::shared_ptr<ItemInstance> item = getSelectedItem(); 1514 1514 - if (item != NULL && std::dynamic_pointer_cast<Mob>( entity ) != NULL) 1514 1514 + if (item != NULL && dynamic_pointer_cast<Mob>( entity ) != NULL) 1515 1515 { 1516 1516 // 4J - PC Comments 1517 1517 // Hack to prevent item stacks from decrementing if the player has 1518 1518 // the ability to instabuild 1519 1519 if(this->abilities.instabuild) item = item->copy(); 1520 1520 - if(item->interactEnemy(std::dynamic_pointer_cast<Mob>(entity))) 1520 1520 + if(item->interactEnemy(dynamic_pointer_cast<Mob>(entity))) 1521 1521 { 1522 1522 // 4J - PC Comments 1523 1523 // Don't remove the item in hand if the player has the ability ··· 1577 1577 1578 1578 int knockback = 0; 1579 1579 int magicBoost = 0; 1580 1580 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(entity); 1580 1580 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(entity); 1581 1581 if (mob != NULL) 1582 1582 { 1583 1583 magicBoost = EnchantmentHelper::getDamageBonus(inventory, mob); ··· 1600 1600 // Ensure we put the entity on fire if we're hitting with a 1601 1601 // fire-enchanted weapon 1602 1602 bool setOnFireTemporatily = false; 1603 1603 - int fireAspect = EnchantmentHelper::getFireAspect(std::dynamic_pointer_cast<Mob>(shared_from_this())); 1604 1604 - if (std::dynamic_pointer_cast<Mob>(entity) && fireAspect > 0 && !entity->isOnFire()) 1603 1603 + int fireAspect = EnchantmentHelper::getFireAspect(dynamic_pointer_cast<Mob>(shared_from_this())); 1604 1604 + if (dynamic_pointer_cast<Mob>(entity) && fireAspect > 0 && !entity->isOnFire()) 1605 1605 { 1606 1606 setOnFireTemporatily = true; 1607 1607 entity->setOnFire(1); 1608 1608 } 1609 1609 1610 1610 - DamageSource *damageSource = DamageSource::playerAttack(std::dynamic_pointer_cast<Player>(shared_from_this())); 1610 1610 + DamageSource *damageSource = DamageSource::playerAttack(dynamic_pointer_cast<Player>(shared_from_this())); 1611 1611 bool wasHurt = entity->hurt(damageSource, dmg); 1612 1612 delete damageSource; 1613 1613 if (wasHurt) ··· 1635 1635 } 1636 1636 setLastHurtMob(entity); 1637 1637 1638 1638 - std::shared_ptr<Mob> mob = std::dynamic_pointer_cast<Mob>(entity); 1638 1638 + std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(entity); 1639 1639 if (mob) 1640 1640 { 1641 1641 ThornsEnchantment::doThornsAfterAttack(shared_from_this(), mob, random); ··· 1643 1643 } 1644 1644 1645 1645 std::shared_ptr<ItemInstance> item = getSelectedItem(); 1646 1646 - if (item != NULL && std::dynamic_pointer_cast<Mob>( entity ) != NULL) 1646 1646 + if (item != NULL && dynamic_pointer_cast<Mob>( entity ) != NULL) 1647 1647 { 1648 1648 - item->hurtEnemy(std::dynamic_pointer_cast<Mob>(entity), std::dynamic_pointer_cast<Player>( shared_from_this() ) ); 1648 1648 + item->hurtEnemy(dynamic_pointer_cast<Mob>(entity), dynamic_pointer_cast<Player>( shared_from_this() ) ); 1649 1649 if (item->count <= 0) 1650 1650 { 1651 1651 removeSelectedItem(); 1652 1652 } 1653 1653 } 1654 1654 - if (std::dynamic_pointer_cast<Mob>( entity ) != NULL) 1654 1654 + if (dynamic_pointer_cast<Mob>( entity ) != NULL) 1655 1655 { 1656 1656 if (entity->isAlive()) 1657 1657 { 1658 1658 - directAllTameWolvesOnTarget(std::dynamic_pointer_cast<Mob>(entity), true); 1658 1658 + directAllTameWolvesOnTarget(dynamic_pointer_cast<Mob>(entity), true); 1659 1659 } 1660 1660 // 4J Stu - Brought forward wasHurt check to Fix 66140 - Bug: Fire Aspect bypasses "Player v Player" being Disabled 1661 1661 if (fireAspect > 0 && wasHurt) ··· 1708 1708 void Player::remove() 1709 1709 { 1710 1710 this->Mob::remove(); 1711 1711 - inventoryMenu->removed( std::dynamic_pointer_cast<Player>( shared_from_this() ) ); 1711 1711 + inventoryMenu->removed( dynamic_pointer_cast<Player>( shared_from_this() ) ); 1712 1712 if (containerMenu != NULL) 1713 1713 { 1714 1714 - containerMenu->removed( std::dynamic_pointer_cast<Player>( shared_from_this() ) ); 1714 1714 + containerMenu->removed( dynamic_pointer_cast<Player>( shared_from_this() ) ); 1715 1715 } 1716 1716 } 1717 1717 ··· 2142 2142 int distance = (int) Math::round(sqrt(dx * dx + dy * dy + dz * dz) * 100.0f); 2143 2143 if (distance > 0) 2144 2144 { 2145 2145 - if ( std::dynamic_pointer_cast<Minecart>( riding ) ) 2145 2145 + if ( dynamic_pointer_cast<Minecart>( riding ) ) 2146 2146 { 2147 2147 distanceMinecart += distance; 2148 2148 if( distanceMinecart >= 100 ) ··· 2189 2189 } 2190 2190 2191 2191 } 2192 2192 - else if (std::dynamic_pointer_cast<Boat>( riding ) != NULL) 2192 2192 + else if (dynamic_pointer_cast<Boat>( riding ) != NULL) 2193 2193 { 2194 2194 distanceBoat += distance; 2195 2195 if( distanceBoat >= 100 ) ··· 2199 2199 awardStat(GenericStats::boatOneM(), GenericStats::param_boat(newDistance/100) ); 2200 2200 } 2201 2201 } 2202 2202 - else if (std::dynamic_pointer_cast<Pig>( riding ) != NULL) 2202 2202 + else if (dynamic_pointer_cast<Pig>( riding ) != NULL) 2203 2203 { 2204 2204 distancePig += distance; 2205 2205 if( distancePig >= 100 ) ··· 2235 2235 void Player::killed(std::shared_ptr<Mob> mob) 2236 2236 { 2237 2237 // 4J-PB - added the lavaslime enemy - fix for #64007 - TU7: Code: Achievements: TCR#073: Killing Magma Cubes doesn't unlock "Monster Hunter" Achievement. 2238 2238 - if( std::dynamic_pointer_cast<Monster>( mob ) != NULL || mob->GetType() == eTYPE_GHAST || mob->GetType() == eTYPE_SLIME || mob->GetType() == eTYPE_LAVASLIME || mob->GetType() == eTYPE_ENDERDRAGON) 2238 2238 + if( dynamic_pointer_cast<Monster>( mob ) != NULL || mob->GetType() == eTYPE_GHAST || mob->GetType() == eTYPE_SLIME || mob->GetType() == eTYPE_LAVASLIME || mob->GetType() == eTYPE_ENDERDRAGON) 2239 2239 { 2240 2240 awardStat(GenericStats::killEnemy(), GenericStats::param_noArgs()); 2241 2241 ··· 2425 2425 2426 2426 // 4J-JEV, hook for ItemUsed event, and ironbelly achievement. 2427 2427 awardStat(GenericStats::itemsUsed(instance->getItem()->id), 2428 2428 - GenericStats::param_itemsUsed(std::dynamic_pointer_cast<Player>(shared_from_this()),instance)); 2428 2428 + GenericStats::param_itemsUsed(dynamic_pointer_cast<Player>(shared_from_this()),instance)); 2429 2429 2430 2430 #if (!defined _DURANGO) && (defined _EXTENDED_ACHIEVEMENTS) 2431 2431 if ( (instance->getItem()->id == Item::rotten_flesh_Id) && (getFoodData()->getFoodLevel() == 0) ) ··· 2774 2774 { 2775 2775 if (getPlayerGamePrivilege(Player::ePlayerGamePrivilege_CanUseContainers) == 0) 2776 2776 { 2777 2777 - std::shared_ptr<Minecart> minecart = std::dynamic_pointer_cast<Minecart>( target ); 2777 2777 + std::shared_ptr<Minecart> minecart = dynamic_pointer_cast<Minecart>( target ); 2778 2778 if (minecart->type == Minecart::CHEST) 2779 2779 allowed = false; 2780 2780 }

+2 -2

Minecraft.World/RandomStrollGoal.cpp

··· 21 21 { 22 22 if (mob->getRandom()->nextInt(120) == 0) 23 23 { 24 24 - Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7); 24 24 + Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7); 25 25 if (pos == NULL) return false; 26 26 wantedX = pos->x; 27 27 wantedY = pos->y; ··· 37 37 38 38 if( mob->isExtraWanderingEnabled() ) 39 39 { 40 40 - Vec3 *pos = RandomPos::getPos(std::dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7,mob->getWanderingQuadrant()); 40 40 + Vec3 *pos = RandomPos::getPos(dynamic_pointer_cast<PathfinderMob>(mob->shared_from_this()), 10, 7,mob->getWanderingQuadrant()); 41 41 if (pos == NULL) return false; 42 42 wantedX = pos->x; 43 43 wantedY = pos->y;

+2 -2

Minecraft.World/RecordPlayerTile.cpp

··· 42 42 { 43 43 if (level->isClientSide) return; 44 44 45 45 - std::shared_ptr<RecordPlayerTile::Entity> rte = std::dynamic_pointer_cast<RecordPlayerTile::Entity>( level->getTileEntity(x, y, z) ); 45 45 + std::shared_ptr<RecordPlayerTile::Entity> rte = dynamic_pointer_cast<RecordPlayerTile::Entity>( level->getTileEntity(x, y, z) ); 46 46 rte->record = record; 47 47 rte->setChanged(); 48 48 ··· 53 53 { 54 54 if (level->isClientSide) return; 55 55 56 56 - std::shared_ptr<RecordPlayerTile::Entity> rte = std::dynamic_pointer_cast<RecordPlayerTile::Entity>( level->getTileEntity(x, y, z) ); 56 56 + std::shared_ptr<RecordPlayerTile::Entity> rte = dynamic_pointer_cast<RecordPlayerTile::Entity>( level->getTileEntity(x, y, z) ); 57 57 if( rte == NULL ) return; 58 58 59 59 int oldRecord = rte->record;

+1 -1

Minecraft.World/ResultSlot.cpp

··· 35 35 36 36 void ResultSlot::checkTakeAchievements(std::shared_ptr<ItemInstance> carried) 37 37 { 38 38 - carried->onCraftedBy(player->level, std::dynamic_pointer_cast<Player>( player->shared_from_this() ), removeCount); 38 38 + carried->onCraftedBy(player->level, dynamic_pointer_cast<Player>( player->shared_from_this() ), removeCount); 39 39 removeCount = 0; 40 40 41 41 if (carried->id == Tile::workBench_Id) player->awardStat(GenericStats::buildWorkbench(), GenericStats::param_buildWorkbench());

+1 -1

Minecraft.World/RotateHeadPacket.cpp

··· 41 41 42 42 bool RotateHeadPacket::isInvalidatedBy(std::shared_ptr<Packet> packet) 43 43 { 44 44 - std::shared_ptr<RotateHeadPacket> target = std::dynamic_pointer_cast<RotateHeadPacket>(packet); 44 44 + std::shared_ptr<RotateHeadPacket> target = dynamic_pointer_cast<RotateHeadPacket>(packet); 45 45 return target->id == id; 46 46 } 47 47

+2 -2

Minecraft.World/SaddleItem.cpp

··· 11 11 12 12 bool SaddleItem::interactEnemy(std::shared_ptr<ItemInstance> itemInstance, std::shared_ptr<Mob> mob) 13 13 { 14 14 - if ( std::dynamic_pointer_cast<Pig>(mob) ) 14 14 + if ( dynamic_pointer_cast<Pig>(mob) ) 15 15 { 16 16 - std::shared_ptr<Pig> pig = std::dynamic_pointer_cast<Pig>(mob); 16 16 + std::shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(mob); 17 17 if (!pig->hasSaddle() && !pig->isBaby()) 18 18 { 19 19 pig->setSaddle(true);

+3 -3

Minecraft.World/SavedDataStorage.cpp

··· 32 32 ConsoleSavePath file = levelStorage->getDataFile(id); 33 33 if (!file.getName().empty() && levelStorage->getSaveFile()->doesFileExist( file ) ) 34 34 { 35 35 - // mob = std::dynamic_pointer_cast<Mob>(Mob::_class->newInstance( level )); 35 35 + // mob = dynamic_pointer_cast<Mob>(Mob::_class->newInstance( level )); 36 36 //data = clazz.getConstructor(String.class).newInstance(id); 37 37 38 38 if( clazz == typeid(MapItemSavedData) ) 39 39 { 40 40 - data = std::dynamic_pointer_cast<SavedData>( std::shared_ptr<MapItemSavedData>(new MapItemSavedData(id)) ); 40 40 + data = dynamic_pointer_cast<SavedData>( std::shared_ptr<MapItemSavedData>(new MapItemSavedData(id)) ); 41 41 } 42 42 else if( clazz == typeid(Villages) ) 43 43 { 44 44 - data = std::dynamic_pointer_cast<SavedData>( std::shared_ptr<Villages>(new Villages(id) ) ); 44 44 + data = dynamic_pointer_cast<SavedData>( std::shared_ptr<Villages>(new Villages(id) ) ); 45 45 } 46 46 else 47 47 {

+1 -1

Minecraft.World/SetEntityMotionPacket.cpp

··· 108 108 109 109 bool SetEntityMotionPacket::isInvalidatedBy(std::shared_ptr<Packet> packet) 110 110 { 111 111 - std::shared_ptr<SetEntityMotionPacket> target = std::dynamic_pointer_cast<SetEntityMotionPacket>(packet); 111 111 + std::shared_ptr<SetEntityMotionPacket> target = dynamic_pointer_cast<SetEntityMotionPacket>(packet); 112 112 return target->id == id; 113 113 }

+1 -1

Minecraft.World/SetEquippedItemPacket.cpp

··· 64 64 65 65 bool SetEquippedItemPacket::isInvalidatedBy(std::shared_ptr<Packet> packet) 66 66 { 67 67 - std::shared_ptr<SetEquippedItemPacket> target = std::dynamic_pointer_cast<SetEquippedItemPacket>(packet); 67 67 + std::shared_ptr<SetEquippedItemPacket> target = dynamic_pointer_cast<SetEquippedItemPacket>(packet); 68 68 return target->entity == entity && target->slot == slot; 69 69 }

+1 -1

Minecraft.World/SetRidingPacket.cpp

··· 48 48 49 49 bool SetRidingPacket::isInvalidatedBy(std::shared_ptr<Packet> packet) 50 50 { 51 51 - std::shared_ptr<SetRidingPacket> target = std::dynamic_pointer_cast<SetRidingPacket>(packet); 51 51 + std::shared_ptr<SetRidingPacket> target = dynamic_pointer_cast<SetRidingPacket>(packet); 52 52 return target->riderId == riderId; 53 53 }

+3 -3

Minecraft.World/Sheep.cpp

··· 277 277 // 4J - added limit to number of animals that can be bred 278 278 if( level->canCreateMore( GetType(), Level::eSpawnType_Breed) ) 279 279 { 280 280 - std::shared_ptr<Sheep> otherSheep = std::dynamic_pointer_cast<Sheep>( target ); 280 280 + std::shared_ptr<Sheep> otherSheep = dynamic_pointer_cast<Sheep>( target ); 281 281 std::shared_ptr<Sheep> sheep = std::shared_ptr<Sheep>( new Sheep(level) ); 282 282 - int color = getOffspringColor(std::dynamic_pointer_cast<Animal>(shared_from_this()), otherSheep); 282 282 + int color = getOffspringColor(dynamic_pointer_cast<Animal>(shared_from_this()), otherSheep); 283 283 sheep->setColor(15 - color); 284 284 return sheep; 285 285 } ··· 333 333 334 334 int Sheep::getDyeColor(std::shared_ptr<Animal> animal) 335 335 { 336 336 - return 15 - std::dynamic_pointer_cast<Sheep>(animal)->getColor(); 336 336 + return 15 - dynamic_pointer_cast<Sheep>(animal)->getColor(); 337 337 }

+1 -1

Minecraft.World/SignItem.cpp

··· 43 43 } 44 44 45 45 instance->count--; 46 46 - std::shared_ptr<SignTileEntity> ste = std::dynamic_pointer_cast<SignTileEntity>( level->getTileEntity(x, y, z) ); 46 46 + std::shared_ptr<SignTileEntity> ste = dynamic_pointer_cast<SignTileEntity>( level->getTileEntity(x, y, z) ); 47 47 if (ste != NULL) player->openTextEdit(ste); 48 48 49 49 // 4J-JEV: Hook for durango 'BlockPlaced' event.

+1 -1

Minecraft.World/SignTile.cpp

··· 80 80 //try { 81 81 // 4J Stu - For some reason the newInstance wasn't working right, but doing it like the other TileEntities is fine 82 82 return std::shared_ptr<TileEntity>( new SignTileEntity() ); 83 83 - //return std::dynamic_pointer_cast<TileEntity>( clas->newInstance() ); 83 83 + //return dynamic_pointer_cast<TileEntity>( clas->newInstance() ); 84 84 //} catch (Exception e) { 85 85 // TODO 4J Stu - Exception handling 86 86 // throw new RuntimeException(e);

+1 -1

Minecraft.World/Silverfish.cpp

··· 86 86 if (attackTime <= 0 && d < 1.2f && target->bb->y1 > bb->y0 && target->bb->y0 < bb->y1) 87 87 { 88 88 attackTime = 20; 89 89 - DamageSource *damageSource = DamageSource::mobAttack( std::dynamic_pointer_cast<Mob>( shared_from_this() ) ); 89 89 + DamageSource *damageSource = DamageSource::mobAttack( dynamic_pointer_cast<Mob>( shared_from_this() ) ); 90 90 target->hurt(damageSource, attackDamage); 91 91 delete damageSource; 92 92 }

+2 -2

Minecraft.World/Skeleton.cpp

··· 101 101 void Skeleton::die(DamageSource *source) 102 102 { 103 103 Monster::die(source); 104 104 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>( source->getEntity() ); 105 105 - if ( std::dynamic_pointer_cast<Arrow>( source->getDirectEntity() ) != NULL && player != NULL) 104 104 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>( source->getEntity() ); 105 105 + if ( dynamic_pointer_cast<Arrow>( source->getDirectEntity() ) != NULL && player != NULL) 106 106 { 107 107 double xd = player->x - x; 108 108 double zd = player->z - z;

+1 -1

Minecraft.World/SkullItem.cpp

··· 46 46 } 47 47 48 48 std::shared_ptr<TileEntity> skullTE = level->getTileEntity(x, y, z); 49 49 - std::shared_ptr<SkullTileEntity> skull = std::dynamic_pointer_cast<SkullTileEntity>(skullTE); 49 49 + std::shared_ptr<SkullTileEntity> skull = dynamic_pointer_cast<SkullTileEntity>(skullTE); 50 50 51 51 if (skull != NULL) 52 52 {

+3 -3

Minecraft.World/SkullTile.cpp

··· 75 75 int SkullTile::cloneTileData(Level *level, int x, int y, int z) 76 76 { 77 77 std::shared_ptr<TileEntity> tileEntity = level->getTileEntity(x, y, z); 78 78 - std::shared_ptr<SkullTileEntity> skull = std::dynamic_pointer_cast<SkullTileEntity>(tileEntity); 78 78 + std::shared_ptr<SkullTileEntity> skull = dynamic_pointer_cast<SkullTileEntity>(tileEntity); 79 79 if (skull != NULL) 80 80 { 81 81 return skull->getSkullType(); ··· 117 117 if ((data & NO_DROP_BIT) == 0) 118 118 { 119 119 std::shared_ptr<ItemInstance> item = std::shared_ptr<ItemInstance>(new ItemInstance(Item::skull_Id, 1, cloneTileData(level, x, y, z))); 120 120 - std::shared_ptr<SkullTileEntity> entity = std::dynamic_pointer_cast<SkullTileEntity>(level->getTileEntity(x, y, z)); 120 120 + std::shared_ptr<SkullTileEntity> entity = dynamic_pointer_cast<SkullTileEntity>(level->getTileEntity(x, y, z)); 121 121 122 122 if (entity->getSkullType() == SkullTileEntity::TYPE_CHAR && !entity->getExtraType().empty()) 123 123 { ··· 245 245 return false; 246 246 } 247 247 std::shared_ptr<TileEntity> te = level->getTileEntity(x, y, z); 248 248 - std::shared_ptr<SkullTileEntity> skull = std::dynamic_pointer_cast<SkullTileEntity>(te); 248 248 + std::shared_ptr<SkullTileEntity> skull = dynamic_pointer_cast<SkullTileEntity>(te); 249 249 if (skull == NULL) 250 250 { 251 251 return false;

+1 -1

Minecraft.World/Slime.cpp

··· 213 213 int size = getSize(); 214 214 if (canSee(player) && this->distanceToSqr(player) < (0.6 * size) * (0.6 * size)) 215 215 { 216 216 - DamageSource *damageSource = DamageSource::mobAttack( std::dynamic_pointer_cast<Mob>( shared_from_this() ) ); 216 216 + DamageSource *damageSource = DamageSource::mobAttack( dynamic_pointer_cast<Mob>( shared_from_this() ) ); 217 217 if (player->hurt(damageSource, getAttackDamage())) 218 218 { 219 219 level->playSound(shared_from_this(), eSoundType_MOB_SLIME_ATTACK, 1, (random->nextFloat() - random->nextFloat()) * 0.2f + 1.0f);

+1 -1

Minecraft.World/SmallFireball.cpp

··· 27 27 { 28 28 if (res->entity != NULL) 29 29 { 30 30 - DamageSource *damageSource = DamageSource::fireball(std::dynamic_pointer_cast<Fireball>(shared_from_this()),owner); 30 30 + DamageSource *damageSource = DamageSource::fireball(dynamic_pointer_cast<Fireball>(shared_from_this()),owner); 31 31 if (!res->entity->isFireImmune() && res->entity->hurt(damageSource, 5)) 32 32 { 33 33 res->entity->setOnFire(5);

+1 -1

Minecraft.World/Snowball.cpp

··· 34 34 if (res->entity != NULL) 35 35 { 36 36 int damage = 0; 37 37 - if (std::dynamic_pointer_cast<Blaze>(res->entity) != NULL) 37 37 + if (dynamic_pointer_cast<Blaze>(res->entity) != NULL) 38 38 { 39 39 damage = 3; 40 40 }

+1 -1

Minecraft.World/StrongholdPieces.cpp

··· 1473 1473 1474 1474 hasPlacedMobSpawner = true; 1475 1475 level->setTile(x, y, z, Tile::mobSpawner_Id); 1476 1476 - std::shared_ptr<MobSpawnerTileEntity> entity = std::dynamic_pointer_cast<MobSpawnerTileEntity>(level->getTileEntity(x, y, z)); 1476 1476 + std::shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>(level->getTileEntity(x, y, z)); 1477 1477 if (entity != NULL) entity->setEntityId(L"Silverfish"); 1478 1478 } 1479 1479 }

+2 -2

Minecraft.World/StructurePiece.cpp

··· 781 781 if ( level->getTile( worldX, worldY, worldZ ) != Tile::chest->id ) 782 782 { 783 783 level->setTile( worldX, worldY, worldZ, Tile::chest->id ); 784 784 - std::shared_ptr<ChestTileEntity> chest = std::dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity( worldX, worldY, worldZ )); 784 784 + std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(level->getTileEntity( worldX, worldY, worldZ )); 785 785 if ( chest != NULL ) WeighedTreasure::addChestItems( random, treasure, chest, numRolls ); 786 786 return true; 787 787 } ··· 800 800 if (level->getTile(worldX, worldY, worldZ) != Tile::dispenser_Id) 801 801 { 802 802 level->setTileAndData(worldX, worldY, worldZ, Tile::dispenser_Id, getOrientationData(Tile::dispenser_Id, facing)); 803 803 - std::shared_ptr<DispenserTileEntity> dispenser = std::dynamic_pointer_cast<DispenserTileEntity>(level->getTileEntity(worldX, worldY, worldZ)); 803 803 + std::shared_ptr<DispenserTileEntity> dispenser = dynamic_pointer_cast<DispenserTileEntity>(level->getTileEntity(worldX, worldY, worldZ)); 804 804 if (dispenser != NULL) WeighedTreasure::addDispenserItems(random, items, dispenser, numRolls); 805 805 return true; 806 806 }

+1 -1

Minecraft.World/TakeFlowerGoal.cpp

··· 33 33 //for (Entity e : golems) 34 34 for(AUTO_VAR(it,golems->begin()); it != golems->end(); ++it) 35 35 { 36 36 - std::shared_ptr<VillagerGolem> vg = std::dynamic_pointer_cast<VillagerGolem>(*it); 36 36 + std::shared_ptr<VillagerGolem> vg = dynamic_pointer_cast<VillagerGolem>(*it); 37 37 if (vg->getOfferFlowerTick() > 0) 38 38 { 39 39 golem = weak_ptr<VillagerGolem>(vg);

+4 -4

Minecraft.World/TargetGoal.cpp

··· 69 69 if (!target->isAlive()) return false; 70 70 if (!mob->canAttackType(target->GetType())) return false; 71 71 72 72 - std::shared_ptr<TamableAnimal> tamableAnimal = std::dynamic_pointer_cast<TamableAnimal>(mob->shared_from_this()); 72 72 + std::shared_ptr<TamableAnimal> tamableAnimal = dynamic_pointer_cast<TamableAnimal>(mob->shared_from_this()); 73 73 if (tamableAnimal != NULL && tamableAnimal->isTame()) 74 74 { 75 75 - std::shared_ptr<TamableAnimal> tamableTarget = std::dynamic_pointer_cast<TamableAnimal>(target); 75 75 + std::shared_ptr<TamableAnimal> tamableTarget = dynamic_pointer_cast<TamableAnimal>(target); 76 76 if (tamableTarget != NULL && tamableTarget->isTame()) return false; 77 77 if (target == tamableAnimal->getOwner()) return false; 78 78 } 79 79 - else if (std::dynamic_pointer_cast<Player>(target) != NULL) 79 79 + else if (dynamic_pointer_cast<Player>(target) != NULL) 80 80 { 81 81 - if (!allowInvulnerable && (std::dynamic_pointer_cast<Player>(target))->abilities.invulnerable) return false; 81 81 + if (!allowInvulnerable && (dynamic_pointer_cast<Player>(target))->abilities.invulnerable) return false; 82 82 } 83 83 84 84 if (!mob->isWithinRestriction(Mth::floor(target->x), Mth::floor(target->y), Mth::floor(target->z))) return false;

+1 -1

Minecraft.World/TeleportEntityPacket.cpp

··· 86 86 87 87 bool TeleportEntityPacket::isInvalidatedBy(std::shared_ptr<Packet> packet) 88 88 { 89 89 - std::shared_ptr<TeleportEntityPacket> target = std::dynamic_pointer_cast<TeleportEntityPacket>(packet); 89 89 + std::shared_ptr<TeleportEntityPacket> target = dynamic_pointer_cast<TeleportEntityPacket>(packet); 90 90 return target->id == id; 91 91 }

+2 -2

Minecraft.World/TheEndPortal.cpp

··· 66 66 { 67 67 if (entity->riding == NULL && entity->rider.lock() == NULL) 68 68 { 69 69 - if (std::dynamic_pointer_cast<Player>(entity) != NULL) 69 69 + if (dynamic_pointer_cast<Player>(entity) != NULL) 70 70 { 71 71 if (!level->isClientSide) 72 72 { ··· 80 80 level->getLevelData()->setHasStrongholdEndPortal(); 81 81 } 82 82 83 83 - (std::dynamic_pointer_cast<Player>(entity))->changeDimension(1); 83 83 + (dynamic_pointer_cast<Player>(entity))->changeDimension(1); 84 84 } 85 85 } 86 86 }

+1 -1

Minecraft.World/ThrownEnderpearl.cpp

··· 47 47 { 48 48 // Fix for #67486 - TCR #001: BAS Game Stability: Customer Encountered: TU8: Code: Gameplay: The title crashes on Host's console when Client Player leaves the game before the Ender Pearl thrown by him touches the ground. 49 49 // If the owner has been removed, then ignore 50 50 - std::shared_ptr<ServerPlayer> serverPlayer = std::dynamic_pointer_cast<ServerPlayer>(owner); 50 50 + std::shared_ptr<ServerPlayer> serverPlayer = dynamic_pointer_cast<ServerPlayer>(owner); 51 51 if (serverPlayer != NULL && !serverPlayer->removed) 52 52 { 53 53 if(!serverPlayer->connection->done && serverPlayer->level == this->level)

+1 -1

Minecraft.World/ThrownPotion.cpp

··· 82 82 for(AUTO_VAR(it, entitiesOfClass->begin()); it != entitiesOfClass->end(); ++it) 83 83 { 84 84 //std::shared_ptr<Entity> e = *it; 85 85 - std::shared_ptr<Mob> e = std::dynamic_pointer_cast<Mob>( *it ); 85 85 + std::shared_ptr<Mob> e = dynamic_pointer_cast<Mob>( *it ); 86 86 double dist = distanceToSqr(e); 87 87 if (dist < SPLASH_RANGE_SQ) 88 88 {

+1 -1

Minecraft.World/TileDestructionPacket.cpp

··· 80 80 81 81 bool TileDestructionPacket::isInvalidatedBy(std::shared_ptr<Packet> packet) 82 82 { 83 83 - std::shared_ptr<TileDestructionPacket> target = std::dynamic_pointer_cast<TileDestructionPacket>(packet); 83 83 + std::shared_ptr<TileDestructionPacket> target = dynamic_pointer_cast<TileDestructionPacket>(packet); 84 84 return target->id == id; 85 85 }

+1 -1

Minecraft.World/TntTile.cpp

··· 98 98 if (entity->GetType() == eTYPE_ARROW && !level->isClientSide) 99 99 { 100 100 // 4J Stu - Don't need to cast this 101 101 - //std::shared_ptr<Arrow> arrow = std::dynamic_pointer_cast<Arrow>(entity); 101 101 + //std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(entity); 102 102 if (entity->isOnFire()) 103 103 { 104 104 destroy(level, x, y, z, EXPLODE_BIT);

+1 -1

Minecraft.World/TreeTile.cpp

··· 63 63 void TreeTile::setPlacedBy(Level *level, int x, int y, int z, std::shared_ptr<Mob> by) 64 64 { 65 65 int type = level->getData(x, y, z) & MASK_TYPE; 66 66 - int dir = PistonBaseTile::getNewFacing(level, x, y, z, std::dynamic_pointer_cast<Player>(by)); 66 66 + int dir = PistonBaseTile::getNewFacing(level, x, y, z, dynamic_pointer_cast<Player>(by)); 67 67 int facing = 0; 68 68 69 69 switch (dir)

+1 -1

Minecraft.World/UpdateMobEffectPacket.cpp

··· 55 55 56 56 bool UpdateMobEffectPacket::isInvalidatedBy(std::shared_ptr<Packet> packet) 57 57 { 58 58 - std::shared_ptr<UpdateMobEffectPacket> target = std::dynamic_pointer_cast<UpdateMobEffectPacket>(packet); 58 58 + std::shared_ptr<UpdateMobEffectPacket> target = dynamic_pointer_cast<UpdateMobEffectPacket>(packet); 59 59 return target->entityId == entityId && target->effectId == effectId; 60 60 }

+3 -3

Minecraft.World/Villager.cpp

··· 157 157 { 158 158 // note: stop() logic is controlled by trading ai goal 159 159 setTradingPlayer(player); 160 160 - player->openTrading(std::dynamic_pointer_cast<Merchant>(shared_from_this())); 160 160 + player->openTrading(dynamic_pointer_cast<Merchant>(shared_from_this())); 161 161 } 162 162 return true; 163 163 } ··· 289 289 { 290 290 _village->addAggressor(mob); 291 291 292 292 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(mob); 292 292 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob); 293 293 if (player) 294 294 { 295 295 int amount = -1; ··· 316 316 { 317 317 if ((sourceEntity->GetType() & eTYPE_PLAYER) == eTYPE_PLAYER) 318 318 { 319 319 - std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(sourceEntity); 319 319 + std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(sourceEntity); 320 320 _village->modifyStanding(player->getName(), -2); 321 321 } 322 322 else if ((sourceEntity->GetType() & eTYPE_ENEMY) == eTYPE_ENEMY)

+1 -1

Minecraft.World/VillagerGolem.cpp

··· 137 137 { 138 138 attackAnimationTick = 10; 139 139 level->broadcastEntityEvent(shared_from_this(), EntityEvent::START_ATTACKING); 140 140 - bool hurt = target->hurt(DamageSource::mobAttack(std::dynamic_pointer_cast<Mob>(shared_from_this())), 7 + random->nextInt(15)); 140 140 + bool hurt = target->hurt(DamageSource::mobAttack(dynamic_pointer_cast<Mob>(shared_from_this())), 7 + random->nextInt(15)); 141 141 if (hurt) target->yd += 0.4f; 142 142 level->playSound(shared_from_this(), eSoundType_MOB_IRONGOLEM_THROW, 1, 1); 143 143 return hurt;

+1 -1

Minecraft.World/WaterLilyTile.cpp

··· 25 25 26 26 void WaterlilyTile::addAABBs(Level *level, int x, int y, int z, AABB *box, AABBList *boxes, std::shared_ptr<Entity> source) 27 27 { 28 28 - if (source == NULL || !(std::dynamic_pointer_cast<Boat>(source))) 28 28 + if (source == NULL || !(dynamic_pointer_cast<Boat>(source))) 29 29 { 30 30 Bush::addAABBs(level, x, y, z, box, boxes, source); 31 31 }

+4 -4

Minecraft.World/Wolf.cpp

··· 63 63 void Wolf::setTarget(std::shared_ptr<Mob> target) 64 64 { 65 65 TamableAnimal::setTarget(target); 66 66 - if ( std::dynamic_pointer_cast<Player>(target) == NULL ) 66 66 + if ( dynamic_pointer_cast<Player>(target) == NULL ) 67 67 { 68 68 setAngry(false); 69 69 } ··· 294 294 if (isInvulnerable()) return false; 295 295 std::shared_ptr<Entity> sourceEntity = source->getEntity(); 296 296 sitGoal->wantToSit(false); 297 297 - if (sourceEntity != NULL && !(std::dynamic_pointer_cast<Player>(sourceEntity) != NULL || std::dynamic_pointer_cast<Arrow>(sourceEntity) != NULL)) 297 297 + if (sourceEntity != NULL && !(dynamic_pointer_cast<Player>(sourceEntity) != NULL || dynamic_pointer_cast<Arrow>(sourceEntity) != NULL)) 298 298 { 299 299 // take half damage from non-players and arrows 300 300 dmg = (dmg + 1) / 2; ··· 305 305 bool Wolf::doHurtTarget(std::shared_ptr<Entity> target) 306 306 { 307 307 int damage = isTame() ? 4 : 2; 308 308 - return target->hurt(DamageSource::mobAttack(std::dynamic_pointer_cast<Mob>(shared_from_this())), damage); 308 308 + return target->hurt(DamageSource::mobAttack(dynamic_pointer_cast<Mob>(shared_from_this())), damage); 309 309 } 310 310 311 311 void Wolf::tame(const wstring &wsOwnerUUID, bool bDisplayTamingParticles, bool bSetSitting) ··· 536 536 { 537 537 if (animal == shared_from_this()) return false; 538 538 if (!isTame()) return false; 539 539 - std::shared_ptr<Wolf> partner = std::dynamic_pointer_cast<Wolf>(animal); 539 539 + std::shared_ptr<Wolf> partner = dynamic_pointer_cast<Wolf>(animal); 540 540 if (partner == NULL) return false; 541 541 if (!partner->isTame()) return false; 542 542 if (partner->isSitting()) return false;