diff options
Diffstat (limited to 'src/Protocol/Protocol_1_14.cpp')
| -rw-r--r-- | src/Protocol/Protocol_1_14.cpp | 1392 |
1 files changed, 1388 insertions, 4 deletions
diff --git a/src/Protocol/Protocol_1_14.cpp b/src/Protocol/Protocol_1_14.cpp index 2c6451e56..dfe137c34 100644 --- a/src/Protocol/Protocol_1_14.cpp +++ b/src/Protocol/Protocol_1_14.cpp @@ -9,10 +9,39 @@ Implements the 1.14 protocol classes: #include "Globals.h" #include "Protocol_1_14.h" #include "Packetizer.h" -#include "../Entities/Player.h" #include "../Root.h" #include "../Server.h" #include "../World.h" +#include "../UI/HorseWindow.h" +#include "../ClientHandle.h" +#include "../WorldStorage/FastNBT.h" +#include "../BlockEntities/BlockEntity.h" + +#include "../Entities/ArrowEntity.h" +#include "../Mobs/Bat.h" +#include "../Entities/Boat.h" +#include "../Mobs/Chicken.h" +#include "../Mobs/Cow.h" +#include "../Mobs/Creeper.h" +#include "../Entities/EnderCrystal.h" +#include "../Mobs/Enderman.h" +#include "../Mobs/Ghast.h" +#include "../Mobs/Horse.h" +#include "../Mobs/MagmaCube.h" +#include "../Entities/Minecart.h" +#include "../Mobs/Ocelot.h" +#include "../Entities/Pickup.h" +#include "../Mobs/Pig.h" +#include "../Entities/Player.h" +#include "../Mobs/Rabbit.h" +#include "../Mobs/Sheep.h" +#include "../Mobs/Skeleton.h" +#include "../Mobs/Slime.h" +#include "../Mobs/Villager.h" +#include "../Mobs/Wolf.h" +#include "../Mobs/Wither.h" +#include "../Mobs/Zombie.h" +#include "../Mobs/ZombiePigman.h" #include "Palettes/Upgrade.h" #include "Palettes/Palette_1_14.h" @@ -21,11 +50,31 @@ Implements the 1.14 protocol classes: +#define HANDLE_READ(ByteBuf, Proc, Type, Var) \ + Type Var; \ + do { \ + if (!ByteBuf.Proc(Var))\ + {\ + return;\ + } \ + } while (false) + + + + + //////////////////////////////////////////////////////////////////////////////// // cProtocol_1_14: void cProtocol_1_14::SendBlockAction(Vector3i a_BlockPos, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) { + ASSERT(m_State == 3); // In game mode? + + cPacketizer Pkt(*this, pktBlockAction); + Pkt.WriteXZYPosition64(a_BlockPos); + Pkt.WriteBEInt8(a_Byte1); + Pkt.WriteBEInt8(a_Byte2); + Pkt.WriteVarInt32(a_BlockType); } @@ -34,6 +83,23 @@ void cProtocol_1_14::SendBlockAction(Vector3i a_BlockPos, char a_Byte1, char a_B void cProtocol_1_14::SendBlockBreakAnim(UInt32 a_EntityID, Vector3i a_BlockPos, char a_Stage) { + ASSERT(m_State == 3); // In game mode? + + cPacketizer Pkt(*this, pktBlockBreakAnim); + Pkt.WriteVarInt32(a_EntityID); + Pkt.WriteXZYPosition64(a_BlockPos); + Pkt.WriteBEInt8(a_Stage); +} + + + + + +void cProtocol_1_14::SendBlockChange(Vector3i a_BlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) +{ + cPacketizer Pkt(*this, pktBlockChange); + Pkt.WriteXZYPosition64(a_BlockPos); + Pkt.WriteVarInt32(GetProtocolBlockType(a_BlockType, a_BlockMeta)); } @@ -64,6 +130,33 @@ void cProtocol_1_14::SendEntityAnimation(const cEntity & a_Entity, EntityAnimati +void cProtocol_1_14::SendEntitySpawn(const cEntity & a_Entity, const UInt8 a_ObjectType, const Int32 a_ObjectData) +{ + ASSERT(m_State == 3); // In game mode? + + cPacketizer Pkt(*this, pktSpawnObject); + Pkt.WriteVarInt32(a_Entity.GetUniqueID()); + + // TODO: Bad way to write a UUID, and it's not a true UUID, but this is functional for now. + Pkt.WriteBEUInt64(0); + Pkt.WriteBEUInt64(a_Entity.GetUniqueID()); + + Pkt.WriteVarInt32(a_ObjectType); + Pkt.WriteBEDouble(a_Entity.GetPosX()); + Pkt.WriteBEDouble(a_Entity.GetPosY()); + Pkt.WriteBEDouble(a_Entity.GetPosZ()); + Pkt.WriteByteAngle(a_Entity.GetPitch()); + Pkt.WriteByteAngle(a_Entity.GetYaw()); + Pkt.WriteBEInt32(a_ObjectData); + Pkt.WriteBEInt16(static_cast<Int16>(a_Entity.GetSpeedX() * 400)); + Pkt.WriteBEInt16(static_cast<Int16>(a_Entity.GetSpeedY() * 400)); + Pkt.WriteBEInt16(static_cast<Int16>(a_Entity.GetSpeedZ() * 400)); +} + + + + + void cProtocol_1_14::SendLogin(const cPlayer & a_Player, const cWorld & a_World) { // Send the Join Game packet: @@ -87,8 +180,9 @@ void cProtocol_1_14::SendLogin(const cPlayer & a_Player, const cWorld & a_World) // Send the server difficulty: { - // cPacketizer Pkt(*this, pktDifficulty); - // Pkt.WriteBEInt8(1); + cPacketizer Pkt(*this, pktDifficulty); + Pkt.WriteBEInt8(1); + Pkt.WriteBool(false); // Difficulty locked? } } @@ -96,6 +190,14 @@ void cProtocol_1_14::SendLogin(const cPlayer & a_Player, const cWorld & a_World) +void cProtocol_1_14::SendMapData(const cMap & a_Map, int a_DataStartX, int a_DataStartY) +{ +} + + + + + void cProtocol_1_14::SendPaintingSpawn(const cPainting & a_Painting) { } @@ -104,8 +206,63 @@ void cProtocol_1_14::SendPaintingSpawn(const cPainting & a_Painting) +void cProtocol_1_14::SendParticleEffect(const AString & a_ParticleName, Vector3f a_Src, Vector3f a_Offset, float a_ParticleData, int a_ParticleAmount, std::array<int, 2> a_Data) +{ + ASSERT(m_State == 3); // In game mode? + + const auto ParticleID = GetProtocolParticleID(a_ParticleName); + + cPacketizer Pkt(*this, pktParticleEffect); + Pkt.WriteBEInt32(ParticleID); + Pkt.WriteBool(false); + Pkt.WriteBEFloat(a_Src.x); + Pkt.WriteBEFloat(a_Src.y); + Pkt.WriteBEFloat(a_Src.z); + Pkt.WriteBEFloat(a_Offset.x); + Pkt.WriteBEFloat(a_Offset.y); + Pkt.WriteBEFloat(a_Offset.z); + Pkt.WriteBEFloat(a_ParticleData); + Pkt.WriteBEInt32(a_ParticleAmount); + + switch (ParticleID) + { + // blockdust + case 3: + { + Pkt.WriteVarInt32(static_cast<UInt32>(a_Data[0])); + break; + } + } +} + + + + + +void cProtocol_1_14::SendRespawn(eDimension a_Dimension) +{ + cPacketizer Pkt(*this, pktRespawn); + cPlayer * Player = m_Client->GetPlayer(); + Pkt.WriteBEInt32(static_cast<Int32>(a_Dimension)); + Pkt.WriteBEUInt8(static_cast<Byte>(Player->GetEffectiveGameMode())); + Pkt.WriteString("default"); +} + + + + + void cProtocol_1_14::SendSoundParticleEffect(const EffectID a_EffectID, Vector3i a_Origin, int a_Data) { + ASSERT(m_State == 3); // In game mode? + + // Note: Particles from block break missing + + cPacketizer Pkt(*this, pktSoundParticleEffect); + Pkt.WriteBEInt32(static_cast<int>(a_EffectID)); + Pkt.WriteXYZPosition64(a_Origin); + Pkt.WriteBEInt32(a_Data); + Pkt.WriteBool(false); } @@ -114,6 +271,48 @@ void cProtocol_1_14::SendSoundParticleEffect(const EffectID a_EffectID, Vector3i void cProtocol_1_14::SendUpdateBlockEntity(cBlockEntity & a_BlockEntity) { + ASSERT(m_State == 3); // In game mode? + + Byte Action; + switch (a_BlockEntity.GetBlockType()) + { + case E_BLOCK_CHEST: + case E_BLOCK_ENCHANTMENT_TABLE: + case E_BLOCK_END_PORTAL: + case E_BLOCK_TRAPPED_CHEST: + { + // The ones with a action of 0 is just a workaround to send the block entities to a client. + // Todo: 18.09.2020 - remove this when block entities are transmitted in the ChunkData packet - 12xx12 + Action = 0; + break; + } + + case E_BLOCK_MOB_SPAWNER: Action = 1; break; // Update mob spawner spinny mob thing + case E_BLOCK_COMMAND_BLOCK: Action = 2; break; // Update command block text + case E_BLOCK_BEACON: Action = 3; break; // Update beacon entity + case E_BLOCK_HEAD: Action = 4; break; // Update Mobhead entity + // case E_BLOCK_CONDUIT: Action = 5; break; // Update Conduit entity + case E_BLOCK_STANDING_BANNER: + case E_BLOCK_WALL_BANNER: Action = 6; break; // Update banner entity + // case Structure Block: Action = 7; break; // Update Structure tile entity + case E_BLOCK_END_GATEWAY: Action = 8; break; // Update destination for a end gateway entity + case E_BLOCK_SIGN_POST: Action = 9; break; // Update sign entity + // case E_BLOCK_SHULKER_BOX: Action = 10; break; // sets shulker box - not used just here if anyone is confused from reading the protocol wiki + case E_BLOCK_BED: Action = 11; break; // Update bed color + // case E_BLOCK_JIGSAW: Action = 12; break; + // case E_BLOCK_CAMPFIRE: Action = 13; break; + + default: return; // Block entities change between versions + } + + cPacketizer Pkt(*this, pktUpdateBlockEntity); + Pkt.WriteXZYPosition64(a_BlockEntity.GetPosX(), a_BlockEntity.GetPosY(), a_BlockEntity.GetPosZ()); + Pkt.WriteBEUInt8(Action); + + cFastNBTWriter Writer; + WriteBlockEntity(Writer, a_BlockEntity); + Writer.Finish(); + Pkt.WriteBuf(Writer.GetResult()); } @@ -128,6 +327,140 @@ void cProtocol_1_14::SendUpdateSign(Vector3i a_BlockPos, const AString & a_Line1 +void cProtocol_1_14::SendWindowOpen(const cWindow & a_Window) +{ + ASSERT(m_State == 3); // In game mode? + + if (a_Window.GetWindowType() < 0) + { + // Do not send this packet for player inventory windows + return; + } + + if (a_Window.GetWindowType() == cWindow::wtAnimalChest) + { + cPacketizer Pkt(*this, pktHorseWindowOpen); + Pkt.WriteBEUInt8(static_cast<UInt8>(a_Window.GetWindowID())); + Pkt.WriteVarInt32(static_cast<UInt32>(a_Window.GetNumSlots())); + + UInt32 HorseID = static_cast<const cHorseWindow &>(a_Window).GetHorseID(); + Pkt.WriteBEInt32(static_cast<Int32>(HorseID)); + } + else + { + cPacketizer Pkt(*this, pktWindowOpen); + Pkt.WriteVarInt32(static_cast<UInt8>(a_Window.GetWindowID())); + + switch (a_Window.GetWindowType()) + { + case cWindow::wtChest: + { + // Chests can have multiple size + Pkt.WriteVarInt32(static_cast<UInt32>(a_Window.GetNumNonInventorySlots() / 9 - 1)); + break; + } + case cWindow::wtDropper: + case cWindow::wtDropSpenser: + { + Pkt.WriteVarInt32(6); + break; + } + case cWindow::wtAnvil: + { + Pkt.WriteVarInt32(7); + break; + } + case cWindow::wtBeacon: + { + Pkt.WriteVarInt32(8); + break; + } + case cWindow::wtBrewery: + { + Pkt.WriteVarInt32(10); + break; + } + case cWindow::wtWorkbench: + { + Pkt.WriteVarInt32(11); + break; + } + case cWindow::wtEnchantment: + { + Pkt.WriteVarInt32(12); + break; + } + case cWindow::wtFurnace: + { + Pkt.WriteVarInt32(13); + break; + } + /* + case cWindow::wtGrindstone: + { + Pkt.WriteVarInt32(14); + break; + } + */ + case cWindow::wtHopper: + { + Pkt.WriteVarInt32(15); + break; + } + /* + case cWindow::wtLectern: + { + Pkt.WriteVarInt32(16); + break; + } + case cWindow::wtLoom: + { + Pkt.WriteVarInt32(17); + break; + } + */ + case cWindow::wtNPCTrade: + { + Pkt.WriteVarInt32(18); + break; + } + /* + case cWindow::wtShulker: + { + Pkt.WriteVarInt32(19); + break; + } + case cWindow::wtSmoker: + { + Pkt.WriteVarInt32(20); + break; + } + case cWindow::wtCartography: + { + Pkt.WriteVarInt32(21); + break; + } + case cWindow::wtStonecutter: + { + Pkt.WriteVarInt32(22); + break; + } + */ + default: + { + Pkt.WriteBEUInt8(static_cast<UInt8>(a_Window.GetNumNonInventorySlots())); + break; + } + } + + Pkt.WriteString(Printf("{\"text\":\"%s\"}", a_Window.GetWindowTitle().c_str())); + } +} + + + + + UInt32 cProtocol_1_14::GetPacketID(ePacketType a_PacketType) const { switch (a_PacketType) @@ -148,6 +481,7 @@ UInt32 cProtocol_1_14::GetPacketID(ePacketType a_PacketType) const case cProtocol::pktExplosion: return 0x1C; case cProtocol::pktGameMode: return 0x1E; case cProtocol::pktHeldItemChange: return 0x3F; + case cProtocol::pktHorseWindowOpen: return 0x1F; case cProtocol::pktInventorySlot: return 0x16; case cProtocol::pktKeepAlive: return 0x20; case cProtocol::pktParticleEffect: return 0x23; @@ -170,6 +504,7 @@ UInt32 cProtocol_1_14::GetPacketID(ePacketType a_PacketType) const case cProtocol::pktUpdateHealth: return 0x48; case cProtocol::pktUpdateScore: return 0x4C; case cProtocol::pktUpdateSign: return 0x2F; + case cProtocol::pktWeather: return 0x1E; case cProtocol::pktWindowItems: return 0x14; case cProtocol::pktWindowOpen: return 0x2E; case cProtocol::pktWindowProperty: return 0x15; @@ -181,6 +516,148 @@ UInt32 cProtocol_1_14::GetPacketID(ePacketType a_PacketType) const +UInt8 cProtocol_1_14::GetEntityMetadataID(EntityMetadata a_Metadata) const +{ + const UInt8 Entity = 7; + const UInt8 Living = Entity + 6; + const UInt8 Insentient = Living + 1; + const UInt8 Ageable = Insentient + 1; + const UInt8 AbstractHorse = Ageable + 2; + const UInt8 ChestedHorse = AbstractHorse + 1; + const UInt8 TameableAnimal = Ageable + 2; + const UInt8 Minecart = Entity + 6; + const UInt8 RaidParticipent = Insentient + 1; + + switch (a_Metadata) + { + case EntityMetadata::EntityFlags: return 0; + case EntityMetadata::EntityAir: return 1; + case EntityMetadata::EntityCustomName: return 2; + case EntityMetadata::EntityCustomNameVisible: return 3; + case EntityMetadata::EntitySilent: return 4; + case EntityMetadata::EntityNoGravity: return 5; + case EntityMetadata::EntityPose: return 6; + case EntityMetadata::ThrowableItem: return Entity; + case EntityMetadata::PotionThrown: return Entity; + case EntityMetadata::FallingBlockPosition: return Entity; + case EntityMetadata::AreaEffectCloudRadius: return Entity; + case EntityMetadata::AreaEffectCloudColor: return Entity + 1; + case EntityMetadata::AreaEffectCloudSinglePointEffect: return Entity + 2; + case EntityMetadata::AreaEffectCloudParticleId: return Entity + 3; + case EntityMetadata::ArrowFlags: return Entity; + case EntityMetadata::PiercingLevel: return Entity + 2; + case EntityMetadata::TippedArrowColor: return Entity + 3; + case EntityMetadata::BoatLastHitTime: return Entity; + case EntityMetadata::BoatForwardDirection: return Entity + 1; + case EntityMetadata::BoatDamageTaken: return Entity + 2; + case EntityMetadata::BoatType: return Entity + 3; + case EntityMetadata::BoatLeftPaddleTurning: return Entity + 4; + case EntityMetadata::BoatRightPaddleTurning: return Entity + 5; + case EntityMetadata::BoatSplashTimer: return Entity + 6; + case EntityMetadata::EnderCrystalBeamTarget: return Entity; + case EntityMetadata::EnderCrystalShowBottom: return Entity + 1; + case EntityMetadata::WitherSkullInvulnerable: return Entity; + case EntityMetadata::FireworkInfo: return Entity; + case EntityMetadata::FireworkBoostedEntityId: return Entity + 1; + case EntityMetadata::FireworkFromCrossbow: return Entity + 2; + case EntityMetadata::ItemFrameItem: return Entity; + case EntityMetadata::ItemFrameRotation: return Entity + 1; + case EntityMetadata::ItemItem: return Entity; + case EntityMetadata::LivingActiveHand: return Entity; + case EntityMetadata::LivingHealth: return Entity + 1; + case EntityMetadata::LivingPotionEffectColor: return Entity + 2; + case EntityMetadata::LivingPotionEffectAmbient: return Entity + 3; + case EntityMetadata::LivingNumberOfArrows: return Entity + 4; + case EntityMetadata::PlayerAdditionalHearts: return Living; + case EntityMetadata::PlayerScore: return Living + 1; + case EntityMetadata::PlayerDisplayedSkinParts: return Living + 2; + case EntityMetadata::PlayerMainHand: return Living + 3; + case EntityMetadata::ArmorStandStatus: return Living; + case EntityMetadata::ArmorStandHeadRotation: return Living + 1; + case EntityMetadata::ArmorStandBodyRotation: return Living + 2; + case EntityMetadata::ArmorStandLeftArmRotation: return Living + 3; + case EntityMetadata::ArmorStandRightArmRotation: return Living + 4; + case EntityMetadata::ArmorStandLeftLegRotation: return Living + 5; + case EntityMetadata::ArmorStandRightLegRotation: return Living + 6; + case EntityMetadata::InsentientFlags: return Living; + case EntityMetadata::BatHanging: return Insentient; + case EntityMetadata::AgeableIsBaby: return Insentient; + case EntityMetadata::AbstractHorseFlags: return Ageable; + case EntityMetadata::AbstractHorseOwner: return Ageable + 1; + case EntityMetadata::HorseVariant: return AbstractHorse; + case EntityMetadata::ChestedHorseChested: return AbstractHorse; + case EntityMetadata::LlamaStrength: return ChestedHorse; + case EntityMetadata::LlamaCarpetColor: return ChestedHorse + 1; + case EntityMetadata::LlamaVariant: return ChestedHorse + 2; + case EntityMetadata::PigHasSaddle: return Ageable; + case EntityMetadata::PigTotalCarrotOnAStickBoost: return Ageable + 1; + case EntityMetadata::RabbitType: return Ageable; + case EntityMetadata::PolarBearStanding: return Ageable; + case EntityMetadata::SheepFlags: return Ageable; + case EntityMetadata::TameableAnimalFlags: return Ageable; + case EntityMetadata::TameableAnimalOwner: return Ageable + 1; + case EntityMetadata::OcelotType: return TameableAnimal; + case EntityMetadata::WolfDamageTaken: return TameableAnimal; + case EntityMetadata::WolfBegging: return TameableAnimal + 1; + case EntityMetadata::WolfCollarColour: return TameableAnimal + 2; + case EntityMetadata::VillagerProfession: return Ageable; + case EntityMetadata::IronGolemPlayerCreated: return Insentient; + case EntityMetadata::ShulkerFacingDirection: return Insentient; + case EntityMetadata::ShulkerAttachmentFallingBlockPosition: return Insentient + 1; + case EntityMetadata::ShulkerShieldHeight: return Insentient + 2; + case EntityMetadata::BlazeOnFire: return Insentient; + case EntityMetadata::CreeperState: return Insentient; + case EntityMetadata::CreeperPowered: return Insentient + 1; + case EntityMetadata::CreeperIgnited: return Insentient + 2; + case EntityMetadata::GuardianStatus: return Insentient; + case EntityMetadata::GuardianTarget: return Insentient + 1; + case EntityMetadata::IllagerFlags: return Insentient; + case EntityMetadata::SpeIlagerSpell: return Insentient + 1; + case EntityMetadata::VexFlags: return Insentient; + case EntityMetadata::AbstractSkeletonArmsSwinging: return Insentient; + case EntityMetadata::SpiderClimbing: return Insentient; + case EntityMetadata::WitchAggresive: return Insentient; + case EntityMetadata::WitherFirstHeadTarget: return Insentient; + case EntityMetadata::WitherSecondHeadTarget: return Insentient + 1; + case EntityMetadata::WitherThirdHeadTarget: return Insentient + 2; + case EntityMetadata::WitherInvulnerableTimer: return Insentient + 3; + case EntityMetadata::ZombieIsBaby: return Insentient; + case EntityMetadata::ZombieHandsRisedUp: return Insentient + 2; + case EntityMetadata::ZombieVillagerConverting: return Insentient + 4; + case EntityMetadata::ZombieVillagerProfession: return Insentient + 5; + case EntityMetadata::EndermanCarriedBlock: return Insentient; + case EntityMetadata::EndermanScreaming: return Insentient + 1; + case EntityMetadata::EnderDragonDragonPhase: return Insentient; + case EntityMetadata::GhastAttacking: return Insentient; + case EntityMetadata::SlimeSize: return Insentient; + case EntityMetadata::MinecartShakingPower: return Entity; + case EntityMetadata::MinecartShakingDirection: return Entity + 1; + case EntityMetadata::MinecartShakingMultiplier: return Entity + 2; + case EntityMetadata::MinecartBlockIDMeta: return Entity + 3; + case EntityMetadata::MinecartBlockY: return Entity + 4; + case EntityMetadata::MinecartShowBlock: return Entity + 5; + case EntityMetadata::MinecartCommandBlockCommand: return Minecart; + case EntityMetadata::MinecartCommandBlockLastOutput: return Minecart + 1; + case EntityMetadata::MinecartFurnacePowered: return Minecart; + case EntityMetadata::TNTPrimedFuseTime: return Entity; + case EntityMetadata::TridentLoyaltyLevel: return Entity + 3; + case EntityMetadata::MooshroomType: return Ageable; + case EntityMetadata::WitchDrinking: return RaidParticipent; + + case EntityMetadata::AreaEffectCloudParticleParameter1: + case EntityMetadata::AreaEffectCloudParticleParameter2: + case EntityMetadata::ZombieUnusedWasType: break; + + default: + break; + } + UNREACHABLE("Retrieved invalid metadata for protocol"); +} + + + + + std::pair<short, short> cProtocol_1_14::GetItemFromProtocolID(UInt32 a_ProtocolID) const { return PaletteUpgrade::ToItem(Palette_1_14::ToItem(a_ProtocolID)); @@ -226,6 +703,55 @@ signed char cProtocol_1_14::GetProtocolEntityStatus(EntityAnimation a_Animation) +UInt8 cProtocol_1_14::GetProtocolEntityType(const cEntity & a_Entity) const +{ + using Type = cEntity::eEntityType; + + switch (a_Entity.GetEntityType()) + { + case Type::etEnderCrystal: return 17; + case Type::etPickup: return 34; + case Type::etFallingBlock: return 25; + case Type::etMinecart: return 41; + case Type::etBoat: return 5; + case Type::etTNT: return 58; + case Type::etProjectile: + { + using PType = cProjectileEntity::eKind; + const auto & Projectile = static_cast<const cProjectileEntity &>(a_Entity); + + switch (Projectile.GetProjectileKind()) + { + case PType::pkArrow: return 2; + case PType::pkSnowball: return 70; + case PType::pkEgg: return 78; + case PType::pkGhastFireball: return 36; + case PType::pkFireCharge: return 68; + case PType::pkEnderPearl: return 79; + case PType::pkExpBottle: return 80; + case PType::pkSplashPotion: return 81; + case PType::pkFirework: return 26; + case PType::pkWitherSkull: return 92; + } + } + case Type::etFloater: return 101; + case Type::etItemFrame: return 35; + case Type::etLeashKnot: return 37; + + // Non-objects must not be sent + case Type::etEntity: + case Type::etPlayer: + case Type::etMonster: + case Type::etExpOrb: + case Type::etPainting: break; + } + UNREACHABLE("Unhandled entity kind"); +} + + + + + UInt32 cProtocol_1_14::GetProtocolItemType(short a_ItemID, short a_ItemDamage) const { return Palette_1_14::From(PaletteUpgrade::FromItem(a_ItemID, a_ItemDamage)); @@ -235,6 +761,167 @@ UInt32 cProtocol_1_14::GetProtocolItemType(short a_ItemID, short a_ItemDamage) c +UInt32 cProtocol_1_14::GetProtocolMobType(eMonsterType a_MobType) const +{ + switch (a_MobType) + { + // Map invalid type to Giant for easy debugging (if this ever spawns, something has gone very wrong) + case mtInvalidType: return 29; + case mtBat: return 3; + case mtBlaze: return 4; + case mtCat: return 6; + case mtCaveSpider: return 7; + case mtChicken: return 8; + case mtCod: return 9; + case mtCow: return 10; + case mtCreeper: return 11; + case mtDonkey: return 12; + case mtDolphin: return 13; + case mtDrowned: return 15; + case mtElderGuardian: return 16; + case mtEnderDragon: return 18; + case mtEnderman: return 19; + case mtEndermite: return 20; + case mtEvoker: return 22; + case mtFox: return 27; + case mtGhast: return 28; + case mtGiant: return 29; + case mtGuardian: return 30; + case mtHorse: return 31; + case mtHusk: return 32; + case mtIllusioner: return 33; + case mtIronGolem: return 85; + case mtLlama: return 38; + case mtMagmaCube: return 40; + case mtMule: return 48; + case mtMooshroom: return 49; + case mtOcelot: return 50; + case mtPanda: return 52; + case mtParrot: return 53; + case mtPig: return 54; + case mtPufferfish: return 55; + case mtPolarBear: return 57; + case mtRabbit: return 59; + case mtSalmon: return 60; + case mtSheep: return 61; + case mtShulker: return 62; + case mtSilverfish: return 64; + case mtSkeleton: return 65; + case mtSkeletonHorse: return 66; + case mtSlime: return 67; + case mtSnowGolem: return 69; + case mtSpider: return 72; + case mtSquid: return 73; + case mtStray: return 74; + case mtTraderLlama: return 75; + case mtTropicalFish: return 76; + case mtTurtle: return 77; + case mtVex: return 83; + case mtVillager: return 84; + case mtVindicator: return 86; + case mtPillager: return 87; + case mtWanderingTrader: return 88; + case mtWitch: return 89; + case mtWither: return 90; + case mtWitherSkeleton: return 91; + case mtWolf: return 93; + case mtZombie: return 94; + case mtZombieHorse: return 95; + case mtZombiePigman: return 56; + case mtZombieVillager: return 96; + case mtPhantom: return 97; + case mtRavager: return 98; + + default: return 0; + } +} + + + + + +int cProtocol_1_14::GetProtocolParticleID(const AString & a_ParticleName) const +{ + static const std::unordered_map<AString, int> ParticleMap + { + // Initialize the ParticleMap: + { "ambiantentity", 0 }, + { "angryvillager", 1 }, + { "barrier", 2 }, + { "blockdust", 3 }, + { "bubble", 4 }, + { "cloud", 5 }, + { "crit", 6 }, + { "damageindicator", 7 }, + { "dragonbreath", 8 }, + { "driplava", 9 }, + { "fallinglava", 10 }, + { "landinglava", 11 }, + { "dripwater", 12 }, + { "fallingwater", 13 }, + { "dust", 14 }, + { "effect", 15 }, + { "elderguardian", 16 }, + { "enchantedhit", 17 }, + { "enchant", 18 }, + { "endrod", 19 }, + { "entityeffect", 20 }, + { "explosionemitter", 21 }, + { "explode", 22 }, + { "fallingdust", 23 }, + { "firework", 24 }, + { "fishing", 25 }, + { "flame", 26 }, + { "flash", 27 }, + { "happyvillager", 28 }, + { "composter", 29 }, + { "heart", 30 }, + { "instanteffect", 31 }, + { "item", 32 }, + { "slime", 33 }, + { "snowball", 34 }, + { "largesmoke", 35 }, + { "lava", 36 }, + { "mycelium", 37 }, + { "note", 38 }, + { "poof", 39 }, + { "portal", 40 }, + { "rain", 41 }, + { "smoke", 42 }, + { "sneeze", 43 }, + { "spit", 44 }, + { "squidink", 45 }, + { "sweepattack", 46 }, + { "totem", 47 }, + { "underwater", 48 }, + { "splash", 49 }, + { "witch", 50 }, + { "bubblepop", 51 }, + { "currentdown", 52 }, + { "bubblecolumnup", 53 }, + { "nautilus", 54 }, + { "dolphin", 55 }, + { "campfirecosysmoke", 56 }, + { "campfiresignalsmoke", 57 }, + }; + + + const auto ParticleName = StrToLower(a_ParticleName); + const auto FindResult = ParticleMap.find(ParticleName); + if (FindResult == ParticleMap.end()) + { + LOGWARNING("Unknown particle: %s", a_ParticleName.c_str()); + ASSERT(!"Unknown particle"); + return 0; + } + + return FindResult->second; +} + + + + + UInt32 cProtocol_1_14::GetProtocolStatisticType(const CustomStatistic a_Statistic) const { return Palette_1_14::From(a_Statistic); @@ -263,8 +950,41 @@ bool cProtocol_1_14::HandlePacket(cByteBuffer & a_ByteBuffer, UInt32 a_PacketTyp // Game switch (a_PacketType) { - default: a_ByteBuffer.SkipRead(a_ByteBuffer.GetReadableSpace()); a_ByteBuffer.CommitRead(); return true; + case 0x03: HandlePacketChatMessage(a_ByteBuffer); return true; + case 0x04: HandlePacketClientStatus(a_ByteBuffer); return true; + case 0x05: HandlePacketClientSettings(a_ByteBuffer); return true; + case 0x06: HandlePacketTabComplete(a_ByteBuffer); return true; + case 0x07: break; // Confirm transaction - not used in Cuberite + case 0x08: HandlePacketEnchantItem(a_ByteBuffer); return true; + case 0x09: HandlePacketWindowClick(a_ByteBuffer); return true; + case 0x0A: HandlePacketWindowClose(a_ByteBuffer); return true; + case 0x0B: HandlePacketPluginMessage(a_ByteBuffer); return true; + case 0x0E: HandlePacketUseEntity(a_ByteBuffer); return true; + case 0x0F: HandlePacketKeepAlive(a_ByteBuffer); return true; + case 0x11: HandlePacketPlayerPos(a_ByteBuffer); return true; + case 0x12: HandlePacketPlayerPosLook(a_ByteBuffer); return true; + case 0x13: HandlePacketPlayerLook(a_ByteBuffer); return true; + case 0x14: HandlePacketPlayer(a_ByteBuffer); return true; + case 0x15: HandlePacketVehicleMove(a_ByteBuffer); return true; + case 0x16: HandlePacketBoatSteer(a_ByteBuffer); return true; + case 0x18: HandleCraftRecipe(a_ByteBuffer); return true; + case 0x19: HandlePacketPlayerAbilities(a_ByteBuffer); return true; + case 0x1A: HandlePacketBlockDig(a_ByteBuffer); return true; + case 0x1C: HandlePacketSteerVehicle(a_ByteBuffer); return true; + case 0x1D: HandlePacketCraftingBookData(a_ByteBuffer); return true; + case 0x1E: HandlePacketNameItem(a_ByteBuffer); return true; + case 0x1F: HandlePacketResourcePackStatus(a_ByteBuffer); return true; + case 0x20: HandlePacketAdvancementTab(a_ByteBuffer); return true; + case 0x22: HandlePacketSetBeaconEffect(a_ByteBuffer); return true; + case 0x23: HandlePacketSlotSelect(a_ByteBuffer); return true; + case 0x26: HandlePacketCreativeInventoryAction(a_ByteBuffer); return true; + case 0x2C: HandlePacketBlockPlace(a_ByteBuffer); return true; + case 0x2D: HandlePacketUseItem(a_ByteBuffer); return true; + + default: break; } + + return Super::HandlePacket(a_ByteBuffer, a_PacketType); } @@ -273,6 +993,16 @@ bool cProtocol_1_14::HandlePacket(cByteBuffer & a_ByteBuffer, UInt32 a_PacketTyp void cProtocol_1_14::HandlePacketBlockDig(cByteBuffer & a_ByteBuffer) { + HANDLE_READ(a_ByteBuffer, ReadBEUInt8, UInt8, Status); + + int BlockX, BlockY, BlockZ; + if (!a_ByteBuffer.ReadXZYPosition64(BlockX, BlockY, BlockZ)) + { + return; + } + + HANDLE_READ(a_ByteBuffer, ReadVarInt, Int32, Face); + m_Client->HandleLeftClick({BlockX, BlockY, BlockZ}, FaceIntToBlockFace(Face), Status); } @@ -281,6 +1011,21 @@ void cProtocol_1_14::HandlePacketBlockDig(cByteBuffer & a_ByteBuffer) void cProtocol_1_14::HandlePacketBlockPlace(cByteBuffer & a_ByteBuffer) { + HANDLE_READ(a_ByteBuffer, ReadVarInt, Int32, Hand); + + int BlockX, BlockY, BlockZ; + if (!a_ByteBuffer.ReadXZYPosition64(BlockX, BlockY, BlockZ)) + { + return; + } + + HANDLE_READ(a_ByteBuffer, ReadVarInt, Int32, Face); + HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, CursorX); + HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, CursorY); + HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, CursorZ); + HANDLE_READ(a_ByteBuffer, ReadBool, bool, InsideBlock); + + m_Client->HandleRightClick({BlockX, BlockY, BlockZ}, FaceIntToBlockFace(Face), {FloorC(CursorX * 16), FloorC(CursorY * 16), FloorC(CursorZ * 16)}, Hand == 0); } @@ -290,3 +1035,642 @@ void cProtocol_1_14::HandlePacketBlockPlace(cByteBuffer & a_ByteBuffer) void cProtocol_1_14::HandlePacketUpdateSign(cByteBuffer & a_ByteBuffer) { } + + + + + +void cProtocol_1_14::WriteEntityMetadata(cPacketizer & a_Pkt, const EntityMetadata a_Metadata, const EntityMetadataType a_FieldType) const +{ + a_Pkt.WriteBEUInt8(GetEntityMetadataID(a_Metadata)); // Index + a_Pkt.WriteBEUInt8(Super::GetEntityMetadataID(a_FieldType)); // Type +} + + + + + +void cProtocol_1_14::WriteEntityMetadata(cPacketizer & a_Pkt, const cEntity & a_Entity) const +{ + // Common metadata: + Int8 Flags = 0; + if (a_Entity.IsOnFire()) + { + Flags |= 0x01; + } + if (a_Entity.IsCrouched()) + { + Flags |= 0x02; + } + if (a_Entity.IsSprinting()) + { + Flags |= 0x08; + } + if (a_Entity.IsRclking()) + { + Flags |= 0x10; + } + if (a_Entity.IsInvisible()) + { + Flags |= 0x20; + } + /* + if (a_Entity.IsGlowing()) + { + Flags |= 0x40; + } + */ + if (a_Entity.IsElytraFlying()) + { + Flags |= 0x80; + } + + WriteEntityMetadata(a_Pkt, EntityMetadata::EntityFlags, EntityMetadataType::Byte); + a_Pkt.WriteBEInt8(Flags); + + switch (a_Entity.GetEntityType()) + { + case cEntity::etPlayer: + { + auto & Player = static_cast<const cPlayer &>(a_Entity); + + // TODO Set player custom name to their name. + // Then it's possible to move the custom name of mobs to the entities + // and to remove the "special" player custom name. + WriteEntityMetadata(a_Pkt, EntityMetadata::EntityCustomName, EntityMetadataType::String); + a_Pkt.WriteString(Player.GetName()); + + WriteEntityMetadata(a_Pkt, EntityMetadata::LivingHealth, EntityMetadataType::Float); + a_Pkt.WriteBEFloat(static_cast<float>(Player.GetHealth())); + + WriteEntityMetadata(a_Pkt, EntityMetadata::PlayerDisplayedSkinParts, EntityMetadataType::Byte); + a_Pkt.WriteBEUInt8(static_cast<UInt8>(Player.GetSkinParts())); + + WriteEntityMetadata(a_Pkt, EntityMetadata::PlayerMainHand, EntityMetadataType::Byte); + a_Pkt.WriteBEUInt8(Player.IsLeftHanded() ? 0 : 1); + break; + } + case cEntity::etPickup: + { + WriteEntityMetadata(a_Pkt, EntityMetadata::ItemItem, EntityMetadataType::Item); + WriteItem(a_Pkt, static_cast<const cPickup &>(a_Entity).GetItem()); + break; + } + case cEntity::etMinecart: + { + WriteEntityMetadata(a_Pkt, EntityMetadata::MinecartShakingPower, EntityMetadataType::VarInt); + + // The following expression makes Minecarts shake more with less health or higher damage taken + auto & Minecart = static_cast<const cMinecart &>(a_Entity); + auto maxHealth = a_Entity.GetMaxHealth(); + auto curHealth = a_Entity.GetHealth(); + a_Pkt.WriteVarInt32(static_cast<UInt32>((maxHealth - curHealth) * Minecart.LastDamage() * 4)); + + WriteEntityMetadata(a_Pkt, EntityMetadata::MinecartShakingDirection, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(1); // (doesn't seem to effect anything) + + WriteEntityMetadata(a_Pkt, EntityMetadata::MinecartShakingMultiplier, EntityMetadataType::Float); + a_Pkt.WriteBEFloat(static_cast<float>(Minecart.LastDamage() + 10)); // or damage taken + + if (Minecart.GetPayload() == cMinecart::mpNone) + { + auto & RideableMinecart = static_cast<const cRideableMinecart &>(Minecart); + const cItem & MinecartContent = RideableMinecart.GetContent(); + if (!MinecartContent.IsEmpty()) + { + WriteEntityMetadata(a_Pkt, EntityMetadata::MinecartBlockIDMeta, EntityMetadataType::VarInt); + int Content = MinecartContent.m_ItemType; + Content |= MinecartContent.m_ItemDamage << 8; + a_Pkt.WriteVarInt32(static_cast<UInt32>(Content)); + + WriteEntityMetadata(a_Pkt, EntityMetadata::MinecartBlockY, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(static_cast<UInt32>(RideableMinecart.GetBlockHeight())); + + WriteEntityMetadata(a_Pkt, EntityMetadata::MinecartShowBlock, EntityMetadataType::Boolean); + a_Pkt.WriteBool(true); + } + } + else if (Minecart.GetPayload() == cMinecart::mpFurnace) + { + WriteEntityMetadata(a_Pkt, EntityMetadata::MinecartFurnacePowered, EntityMetadataType::Boolean); + a_Pkt.WriteBool(static_cast<const cMinecartWithFurnace &>(Minecart).IsFueled()); + } + break; + } // case etMinecart + + case cEntity::etProjectile: + { + auto & Projectile = static_cast<const cProjectileEntity &>(a_Entity); + switch (Projectile.GetProjectileKind()) + { + case cProjectileEntity::pkArrow: + { + WriteEntityMetadata(a_Pkt, EntityMetadata::ArrowFlags, EntityMetadataType::Byte); + a_Pkt.WriteBEInt8(static_cast<const cArrowEntity &>(Projectile).IsCritical() ? 1 : 0); + + // TODO: Piercing level + break; + } + case cProjectileEntity::pkFirework: + { + // TODO + break; + } + case cProjectileEntity::pkSplashPotion: + { + // TODO + } + default: + { + break; + } + } + break; + } // case etProjectile + + case cEntity::etMonster: + { + WriteMobMetadata(a_Pkt, static_cast<const cMonster &>(a_Entity)); + break; + } + + case cEntity::etBoat: + { + auto & Boat = static_cast<const cBoat &>(a_Entity); + + WriteEntityMetadata(a_Pkt, EntityMetadata::BoatLastHitTime, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(static_cast<UInt32>(Boat.GetLastDamage())); + + WriteEntityMetadata(a_Pkt, EntityMetadata::BoatForwardDirection, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(static_cast<UInt32>(Boat.GetForwardDirection())); + + WriteEntityMetadata(a_Pkt, EntityMetadata::BoatDamageTaken, EntityMetadataType::Float); + a_Pkt.WriteBEFloat(Boat.GetDamageTaken()); + + WriteEntityMetadata(a_Pkt, EntityMetadata::BoatType, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(static_cast<UInt32>(Boat.GetMaterial())); + + WriteEntityMetadata(a_Pkt, EntityMetadata::BoatRightPaddleTurning, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Boat.IsRightPaddleUsed()); + + WriteEntityMetadata(a_Pkt, EntityMetadata::BoatLeftPaddleTurning, EntityMetadataType::Boolean); + a_Pkt.WriteBool(static_cast<bool>(Boat.IsLeftPaddleUsed())); + + WriteEntityMetadata(a_Pkt, EntityMetadata::BoatSplashTimer, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(0); + + break; + } // case etBoat + + case cEntity::etItemFrame: + { + // TODO + break; + } // case etItemFrame + + case cEntity::etEnderCrystal: + { + const auto & EnderCrystal = static_cast<const cEnderCrystal &>(a_Entity); + if (EnderCrystal.DisplaysBeam()) + { + WriteEntityMetadata(a_Pkt, EntityMetadata::EnderCrystalBeamTarget, EntityMetadataType::OptPosition); + a_Pkt.WriteBool(true); // Dont do a second check if it should display the beam + a_Pkt.WriteXYZPosition64(EnderCrystal.GetBeamTarget()); + } + WriteEntityMetadata(a_Pkt, EntityMetadata::EnderCrystalShowBottom, EntityMetadataType::Boolean); + a_Pkt.WriteBool(EnderCrystal.ShowsBottom()); + break; + } // case etEnderCrystal + + default: + { + break; + } + } +} + + + + + +void cProtocol_1_14::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_Mob) const +{ + // Living Enitiy Metadata + if (a_Mob.HasCustomName()) + { + // TODO: As of 1.9 _all_ entities can have custom names; should this be moved up? + WriteEntityMetadata(a_Pkt, EntityMetadata::EntityCustomName, EntityMetadataType::OptChat); + a_Pkt.WriteBool(true); + a_Pkt.WriteString(a_Mob.GetCustomName()); + + WriteEntityMetadata(a_Pkt, EntityMetadata::EntityCustomNameVisible, EntityMetadataType::Boolean); + a_Pkt.WriteBool(a_Mob.IsCustomNameAlwaysVisible()); + } + + WriteEntityMetadata(a_Pkt, EntityMetadata::LivingHealth, EntityMetadataType::Float); + a_Pkt.WriteBEFloat(static_cast<float>(a_Mob.GetHealth())); + + // TODO: pose + + switch (a_Mob.GetMobType()) + { + case mtBat: + { + auto & Bat = static_cast<const cBat &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::BatHanging, EntityMetadataType::Byte); + a_Pkt.WriteBEInt8(Bat.IsHanging() ? 1 : 0); + break; + } // case mtBat + + case mtChicken: + { + auto & Chicken = static_cast<const cChicken &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::AgeableIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Chicken.IsBaby()); + break; + } // case mtChicken + + case mtCow: + { + auto & Cow = static_cast<const cCow &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::AgeableIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Cow.IsBaby()); + break; + } // case mtCow + + case mtCreeper: + { + auto & Creeper = static_cast<const cCreeper &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::CreeperState, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(Creeper.IsBlowing() ? 1 : static_cast<UInt32>(-1)); // (idle or "blowing") + + WriteEntityMetadata(a_Pkt, EntityMetadata::CreeperPowered, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Creeper.IsCharged()); + + WriteEntityMetadata(a_Pkt, EntityMetadata::CreeperIgnited, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Creeper.IsBurnedWithFlintAndSteel()); + break; + } // case mtCreeper + + case mtEnderman: + { + auto & Enderman = static_cast<const cEnderman &>(a_Mob); + WriteEntityMetadata(a_Pkt, EntityMetadata::EndermanCarriedBlock, EntityMetadataType::OptBlockID); + UInt32 Carried = 0; + Carried |= static_cast<UInt32>(Enderman.GetCarriedBlock() << 4); + Carried |= Enderman.GetCarriedMeta(); + a_Pkt.WriteVarInt32(Carried); + + WriteEntityMetadata(a_Pkt, EntityMetadata::EndermanScreaming, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Enderman.IsScreaming()); + break; + } // case mtEnderman + + case mtGhast: + { + auto & Ghast = static_cast<const cGhast &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::GhastAttacking, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Ghast.IsCharging()); + break; + } // case mtGhast + + case mtHorse: + { + // XXX This behaves incorrectly with different varients; horses have different entity IDs now + + // Abstract horse + auto & Horse = static_cast<const cHorse &>(a_Mob); + + Int8 Flags = 0; + if (Horse.IsTame()) + { + Flags |= 0x02; + } + if (Horse.IsSaddled()) + { + Flags |= 0x04; + } + if (Horse.IsInLoveCooldown()) + { + Flags |= 0x08; + } + if (Horse.IsEating()) + { + Flags |= 0x10; + } + if (Horse.IsRearing()) + { + Flags |= 0x20; + } + if (Horse.IsMthOpen()) + { + Flags |= 0x40; + } + WriteEntityMetadata(a_Pkt, EntityMetadata::AbstractHorseFlags, EntityMetadataType::Byte); + a_Pkt.WriteBEInt8(Flags); + + // Regular horses + int Appearance = 0; + Appearance = Horse.GetHorseColor(); + Appearance |= Horse.GetHorseStyle() << 8; + WriteEntityMetadata(a_Pkt, EntityMetadata::HorseVariant, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(static_cast<UInt32>(Appearance)); // Color / style + + WriteEntityMetadata(a_Pkt, EntityMetadata::AgeableIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Horse.IsBaby()); + break; + } // case mtHorse + + case mtMagmaCube: + { + auto & MagmaCube = static_cast<const cMagmaCube &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::SlimeSize, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(static_cast<UInt32>(MagmaCube.GetSize())); + break; + } // case mtMagmaCube + + case mtOcelot: + { + auto & Ocelot = static_cast<const cOcelot &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::AgeableIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Ocelot.IsBaby()); + + // TODO: Ocelot trusting + + break; + } // case mtOcelot + + case mtPig: + { + auto & Pig = static_cast<const cPig &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::AgeableIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Pig.IsBaby()); + + WriteEntityMetadata(a_Pkt, EntityMetadata::PigHasSaddle, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Pig.IsSaddled()); + + // PIG_TOTAL_CARROT_ON_A_STICK_BOOST in 1.11.1 only + break; + } // case mtPig + + case mtRabbit: + { + auto & Rabbit = static_cast<const cRabbit &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::AgeableIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Rabbit.IsBaby()); + + WriteEntityMetadata(a_Pkt, EntityMetadata::RabbitType, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(static_cast<UInt32>(Rabbit.GetRabbitType())); + break; + } // case mtRabbit + + case mtSheep: + { + auto & Sheep = static_cast<const cSheep &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::AgeableIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Sheep.IsBaby()); + + Int8 SheepMetadata = 0; + SheepMetadata = static_cast<Int8>(Sheep.GetFurColor()); + if (Sheep.IsSheared()) + { + SheepMetadata |= 0x10; + } + WriteEntityMetadata(a_Pkt, EntityMetadata::SheepFlags, EntityMetadataType::Byte); + a_Pkt.WriteBEInt8(SheepMetadata); + break; + } // case mtSheep + + case mtSkeleton: + { + auto & Skeleton = static_cast<const cSkeleton &>(a_Mob); + WriteEntityMetadata(a_Pkt, EntityMetadata::LivingActiveHand, EntityMetadataType::Byte); + a_Pkt.WriteBEUInt8(Skeleton.IsChargingBow() ? 0x01 : 0x00); + + // TODO: Skeleton animation + break; + } // case mtSkeleton + + case mtSlime: + { + auto & Slime = static_cast<const cSlime &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::SlimeSize, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(static_cast<UInt32>(Slime.GetSize())); + break; + } // case mtSlime + + case mtVillager: + { + auto & Villager = static_cast<const cVillager &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::AgeableIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Villager.IsBaby()); + + WriteEntityMetadata(a_Pkt, EntityMetadata::VillagerProfession, EntityMetadataType::VillagerData); + a_Pkt.WriteVarInt32(2); // Villager from plains + switch (Villager.GetVilType()) + { + case cVillager::vtFarmer: + { + a_Pkt.WriteVarInt32(5); + break; + } + case cVillager::vtLibrarian: + { + a_Pkt.WriteVarInt32(9); + break; + } + case cVillager::vtPriest: + { + a_Pkt.WriteVarInt32(4); + break; + } + case cVillager::vtBlacksmith: + { + a_Pkt.WriteVarInt32(13); + break; + } + case cVillager::vtButcher: + { + a_Pkt.WriteVarInt32(2); + break; + } + case cVillager::vtGeneric: + { + a_Pkt.WriteVarInt32(0); + break; + } + } + a_Pkt.WriteVarInt32(1); // Level 1 villager + break; + } // case mtVillager + + case mtWitch: + { + // auto & Witch = static_cast<const cWitch &>(a_Mob); + + // TODO: Witch drinking potion + break; + } // case mtWitch + + case mtWither: + { + auto & Wither = static_cast<const cWither &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::WitherInvulnerableTimer, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(Wither.GetWitherInvulnerableTicks()); + + // TODO: Use boss bar packet for health + break; + } // case mtWither + + case mtWolf: + { + auto & Wolf = static_cast<const cWolf &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::AgeableIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Wolf.IsBaby()); + + Int8 WolfStatus = 0; + if (Wolf.IsSitting()) + { + WolfStatus |= 0x1; + } + if (Wolf.IsAngry()) + { + WolfStatus |= 0x2; + } + if (Wolf.IsTame()) + { + WolfStatus |= 0x4; + } + WriteEntityMetadata(a_Pkt, EntityMetadata::TameableAnimalFlags, EntityMetadataType::Byte); + a_Pkt.WriteBEInt8(WolfStatus); + + WriteEntityMetadata(a_Pkt, EntityMetadata::WolfDamageTaken, EntityMetadataType::Float); + a_Pkt.WriteBEFloat(static_cast<float>(a_Mob.GetHealth())); // TODO Not use the current health + + WriteEntityMetadata(a_Pkt, EntityMetadata::WolfBegging, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Wolf.IsBegging()); + + WriteEntityMetadata(a_Pkt, EntityMetadata::WolfCollarColour, EntityMetadataType::VarInt); + a_Pkt.WriteVarInt32(static_cast<UInt32>(Wolf.GetCollarColor())); + break; + } // case mtWolf + + case mtZombie: + { + // XXX Zombies were also split into new sublcasses; this doesn't handle that. + + auto & Zombie = static_cast<const cZombie &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::ZombieIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(Zombie.IsBaby()); + break; + } // case mtZombie + + case mtZombiePigman: + { + auto & ZombiePigman = static_cast<const cZombiePigman &>(a_Mob); + + WriteEntityMetadata(a_Pkt, EntityMetadata::AgeableIsBaby, EntityMetadataType::Boolean); + a_Pkt.WriteBool(ZombiePigman.IsBaby()); + break; + } // case mtZombiePigman + + case mtBlaze: + case mtEnderDragon: + case mtIronGolem: + case mtSnowGolem: + case mtSpider: + case mtZombieVillager: + + case mtElderGuardian: + case mtGuardian: + { + // TODO: Mobs with extra fields that aren't implemented + break; + } + + case mtCat: + + case mtCod: + + case mtDolphin: + + case mtDonkey: + + case mtDrowned: + + case mtEndermite: + + case mtEvoker: + + case mtIllusioner: + + case mtLlama: + + case mtMule: + + case mtParrot: + + case mtPhantom: + + case mtPolarBear: + + case mtPufferfish: + + case mtSalmon: + + case mtShulker: + + case mtStray: + + case mtSkeletonHorse: + case mtZombieHorse: + + case mtTropicalFish: + + case mtTurtle: + + case mtVex: + + case mtVindicator: + + case mtHusk: + { + // Todo: Mobs not added yet. Grouped ones have the same metadata + ASSERT(!"cProtocol_1_14::WriteMobMetadata: received unimplemented type"); + break; + } + + case mtMooshroom: + case mtCaveSpider: + { + // Not mentioned on http://wiki.vg/Entities + break; + } + + case mtGiant: + case mtSilverfish: + case mtSquid: + case mtWitherSkeleton: + { + // Mobs with no extra fields + break; + } + + default: UNREACHABLE("cProtocol_1_14::WriteMobMetadata: received mob of invalid type"); + } // switch (a_Mob.GetType()) +} |