diff options
Diffstat (limited to 'source/game/StarNetPackets.cpp')
| -rw-r--r-- | source/game/StarNetPackets.cpp | 1264 |
1 files changed, 1264 insertions, 0 deletions
diff --git a/source/game/StarNetPackets.cpp b/source/game/StarNetPackets.cpp new file mode 100644 index 0000000..11944f5 --- /dev/null +++ b/source/game/StarNetPackets.cpp @@ -0,0 +1,1264 @@ +#include "StarNetPackets.hpp" +#include "StarDataStreamExtra.hpp" + +namespace Star { + +VersionNumber const StarProtocolVersion = 747; + +EnumMap<PacketType> const PacketTypeNames{ + {PacketType::ProtocolRequest, "ProtocolRequest"}, + {PacketType::ProtocolResponse, "ProtocolResponse"}, + {PacketType::ServerDisconnect, "ServerDisconnect"}, + {PacketType::ConnectSuccess, "ConnectSuccess"}, + {PacketType::ConnectFailure, "ConnectFailure"}, + {PacketType::HandshakeChallenge, "HandshakeChallenge"}, + {PacketType::ChatReceive, "ChatReceive"}, + {PacketType::UniverseTimeUpdate, "UniverseTimeUpdate"}, + {PacketType::CelestialResponse, "CelestialResponse"}, + {PacketType::PlayerWarpResult, "PlayerWarpResult"}, + {PacketType::PlanetTypeUpdate, "PlanetTypeUpdate"}, + {PacketType::Pause, "Pause"}, + {PacketType::ServerInfo, "ServerInfo"}, + {PacketType::ClientConnect, "ClientConnect"}, + {PacketType::ClientDisconnectRequest, "ClientDisconnectRequest"}, + {PacketType::HandshakeResponse, "HandshakeResponse"}, + {PacketType::PlayerWarp, "PlayerWarp"}, + {PacketType::FlyShip, "FlyShip"}, + {PacketType::ChatSend, "ChatSend"}, + {PacketType::CelestialRequest, "CelestialRequest"}, + {PacketType::ClientContextUpdate, "ClientContextUpdate"}, + {PacketType::WorldStart, "WorldStart"}, + {PacketType::WorldStop, "WorldStop"}, + {PacketType::WorldLayoutUpdate, "WorldLayoutUpdate"}, + {PacketType::WorldParametersUpdate, "WorldParametersUpdate"}, + {PacketType::CentralStructureUpdate, "CentralStructureUpdate"}, + {PacketType::TileArrayUpdate, "TileArrayUpdate"}, + {PacketType::TileUpdate, "TileUpdate"}, + {PacketType::TileLiquidUpdate, "TileLiquidUpdate"}, + {PacketType::TileDamageUpdate, "TileDamageUpdate"}, + {PacketType::TileModificationFailure, "TileModificationFailure"}, + {PacketType::GiveItem, "GiveItem"}, + {PacketType::EnvironmentUpdate, "EnvironmentUpdate"}, + {PacketType::UpdateTileProtection, "UpdateTileProtection"}, + {PacketType::SetDungeonGravity, "SetDungeonGravity"}, + {PacketType::SetDungeonBreathable, "SetDungeonBreathable"}, + {PacketType::SetPlayerStart, "SetPlayerStart"}, + {PacketType::FindUniqueEntityResponse, "FindUniqueEntityResponse"}, + {PacketType::Pong, "Pong"}, + {PacketType::ModifyTileList, "ModifyTileList"}, + {PacketType::DamageTileGroup, "DamageTileGroup"}, + {PacketType::CollectLiquid, "CollectLiquid"}, + {PacketType::RequestDrop, "RequestDrop"}, + {PacketType::SpawnEntity, "SpawnEntity"}, + {PacketType::ConnectWire, "ConnectWire"}, + {PacketType::DisconnectAllWires, "DisconnectAllWires"}, + {PacketType::WorldClientStateUpdate, "WorldClientStateUpdate"}, + {PacketType::FindUniqueEntity, "FindUniqueEntity"}, + {PacketType::WorldStartAcknowledge, "WorldStartAcknowledge"}, + {PacketType::Ping, "Ping"}, + {PacketType::EntityCreate, "EntityCreate"}, + {PacketType::EntityUpdateSet, "EntityUpdate"}, + {PacketType::EntityDestroy, "EntityDestroy"}, + {PacketType::EntityInteract, "EntityInteract"}, + {PacketType::EntityInteractResult, "EntityInteractResult"}, + {PacketType::HitRequest, "HitRequest"}, + {PacketType::DamageRequest, "DamageRequest"}, + {PacketType::DamageNotification, "DamageNotification"}, + {PacketType::EntityMessage, "EntityMessage"}, + {PacketType::EntityMessageResponse, "EntityMessageResponse"}, + {PacketType::UpdateWorldProperties, "UpdateWorldProperties"}, + {PacketType::StepUpdate, "StepUpdate"}, + {PacketType::SystemWorldStart, "SystemWorldStart"}, + {PacketType::SystemWorldUpdate, "SystemWorldUpdate"}, + {PacketType::SystemObjectCreate, "SystemObjectCreate"}, + {PacketType::SystemObjectDestroy, "SystemObjectDestroy"}, + {PacketType::SystemShipCreate, "SystemShipCreate"}, + {PacketType::SystemShipDestroy, "SystemShipDestroy"}, + {PacketType::SystemObjectSpawn, "SystemObjectSpawn"} +}; + +Packet::~Packet() {} + +PacketPtr createPacket(PacketType type) { + if (type == PacketType::ProtocolRequest) + return make_shared<ProtocolRequestPacket>(); + else if (type == PacketType::ProtocolResponse) + return make_shared<ProtocolResponsePacket>(); + else if (type == PacketType::ServerDisconnect) + return make_shared<ServerDisconnectPacket>(); + else if (type == PacketType::ConnectSuccess) + return make_shared<ConnectSuccessPacket>(); + else if (type == PacketType::ConnectFailure) + return make_shared<ConnectFailurePacket>(); + else if (type == PacketType::HandshakeChallenge) + return make_shared<HandshakeChallengePacket>(); + else if (type == PacketType::ChatReceive) + return make_shared<ChatReceivePacket>(); + else if (type == PacketType::UniverseTimeUpdate) + return make_shared<UniverseTimeUpdatePacket>(); + else if (type == PacketType::CelestialResponse) + return make_shared<CelestialResponsePacket>(); + else if (type == PacketType::PlayerWarpResult) + return make_shared<PlayerWarpResultPacket>(); + else if (type == PacketType::PlanetTypeUpdate) + return make_shared<PlanetTypeUpdatePacket>(); + else if (type == PacketType::Pause) + return make_shared<PausePacket>(); + else if (type == PacketType::ServerInfo) + return make_shared<ServerInfoPacket>(); + else if (type == PacketType::ClientConnect) + return make_shared<ClientConnectPacket>(); + else if (type == PacketType::ClientDisconnectRequest) + return make_shared<ClientDisconnectRequestPacket>(); + else if (type == PacketType::HandshakeResponse) + return make_shared<HandshakeResponsePacket>(); + else if (type == PacketType::PlayerWarp) + return make_shared<PlayerWarpPacket>(); + else if (type == PacketType::FlyShip) + return make_shared<FlyShipPacket>(); + else if (type == PacketType::ChatSend) + return make_shared<ChatSendPacket>(); + else if (type == PacketType::CelestialRequest) + return make_shared<CelestialRequestPacket>(); + else if (type == PacketType::ClientContextUpdate) + return make_shared<ClientContextUpdatePacket>(); + else if (type == PacketType::WorldStart) + return make_shared<WorldStartPacket>(); + else if (type == PacketType::WorldStop) + return make_shared<WorldStopPacket>(); + else if (type == PacketType::WorldLayoutUpdate) + return make_shared<WorldLayoutUpdatePacket>(); + else if (type == PacketType::WorldParametersUpdate) + return make_shared<WorldParametersUpdatePacket>(); + else if (type == PacketType::CentralStructureUpdate) + return make_shared<CentralStructureUpdatePacket>(); + else if (type == PacketType::TileArrayUpdate) + return make_shared<TileArrayUpdatePacket>(); + else if (type == PacketType::TileUpdate) + return make_shared<TileUpdatePacket>(); + else if (type == PacketType::TileLiquidUpdate) + return make_shared<TileLiquidUpdatePacket>(); + else if (type == PacketType::TileDamageUpdate) + return make_shared<TileDamageUpdatePacket>(); + else if (type == PacketType::TileModificationFailure) + return make_shared<TileModificationFailurePacket>(); + else if (type == PacketType::GiveItem) + return make_shared<GiveItemPacket>(); + else if (type == PacketType::EnvironmentUpdate) + return make_shared<EnvironmentUpdatePacket>(); + else if (type == PacketType::ModifyTileList) + return make_shared<ModifyTileListPacket>(); + else if (type == PacketType::DamageTileGroup) + return make_shared<DamageTileGroupPacket>(); + else if (type == PacketType::CollectLiquid) + return make_shared<CollectLiquidPacket>(); + else if (type == PacketType::RequestDrop) + return make_shared<RequestDropPacket>(); + else if (type == PacketType::SpawnEntity) + return make_shared<SpawnEntityPacket>(); + else if (type == PacketType::EntityInteract) + return make_shared<EntityInteractPacket>(); + else if (type == PacketType::EntityInteractResult) + return make_shared<EntityInteractResultPacket>(); + else if (type == PacketType::UpdateTileProtection) + return make_shared<UpdateTileProtectionPacket>(); + else if (type == PacketType::SetDungeonGravity) + return make_shared<SetDungeonGravityPacket>(); + else if (type == PacketType::SetDungeonBreathable) + return make_shared<SetDungeonBreathablePacket>(); + else if (type == PacketType::SetPlayerStart) + return make_shared<SetPlayerStartPacket>(); + else if (type == PacketType::FindUniqueEntityResponse) + return make_shared<FindUniqueEntityResponsePacket>(); + else if (type == PacketType::Pong) + return make_shared<PongPacket>(); + else if (type == PacketType::ConnectWire) + return make_shared<ConnectWirePacket>(); + else if (type == PacketType::DisconnectAllWires) + return make_shared<DisconnectAllWiresPacket>(); + else if (type == PacketType::WorldClientStateUpdate) + return make_shared<WorldClientStateUpdatePacket>(); + else if (type == PacketType::FindUniqueEntity) + return make_shared<FindUniqueEntityPacket>(); + else if (type == PacketType::WorldStartAcknowledge) + return make_shared<WorldStartAcknowledgePacket>(); + else if (type == PacketType::Ping) + return make_shared<PingPacket>(); + else if (type == PacketType::EntityCreate) + return make_shared<EntityCreatePacket>(); + else if (type == PacketType::EntityUpdateSet) + return make_shared<EntityUpdateSetPacket>(); + else if (type == PacketType::EntityDestroy) + return make_shared<EntityDestroyPacket>(); + else if (type == PacketType::HitRequest) + return make_shared<HitRequestPacket>(); + else if (type == PacketType::DamageRequest) + return make_shared<DamageRequestPacket>(); + else if (type == PacketType::DamageNotification) + return make_shared<DamageNotificationPacket>(); + else if (type == PacketType::EntityMessage) + return make_shared<EntityMessagePacket>(); + else if (type == PacketType::EntityMessageResponse) + return make_shared<EntityMessageResponsePacket>(); + else if (type == PacketType::UpdateWorldProperties) + return make_shared<UpdateWorldPropertiesPacket>(); + else if (type == PacketType::StepUpdate) + return make_shared<StepUpdatePacket>(); + else if (type == PacketType::SystemWorldStart) + return make_shared<SystemWorldStartPacket>(); + else if (type == PacketType::SystemWorldUpdate) + return make_shared<SystemWorldUpdatePacket>(); + else if (type == PacketType::SystemObjectCreate) + return make_shared<SystemObjectCreatePacket>(); + else if (type == PacketType::SystemObjectDestroy) + return make_shared<SystemObjectDestroyPacket>(); + else if (type == PacketType::SystemShipCreate) + return make_shared<SystemShipCreatePacket>(); + else if (type == PacketType::SystemShipDestroy) + return make_shared<SystemShipDestroyPacket>(); + else if (type == PacketType::SystemObjectSpawn) + return make_shared<SystemObjectSpawnPacket>(); + else + throw StarPacketException(strf("Unrecognized packet type %s", (unsigned)type)); +} + +ProtocolRequestPacket::ProtocolRequestPacket() + : requestProtocolVersion(0) {} + +ProtocolRequestPacket::ProtocolRequestPacket(VersionNumber requestProtocolVersion) + : requestProtocolVersion(requestProtocolVersion) {} + +void ProtocolRequestPacket::read(DataStream& ds) { + ds.read(requestProtocolVersion); +} + +void ProtocolRequestPacket::write(DataStream& ds) const { + ds.write(requestProtocolVersion); +} + +ProtocolResponsePacket::ProtocolResponsePacket(bool allowed) + : allowed(allowed) {} + +void ProtocolResponsePacket::read(DataStream& ds) { + ds.read(allowed); +} + +void ProtocolResponsePacket::write(DataStream& ds) const { + ds.write(allowed); +} + +ConnectSuccessPacket::ConnectSuccessPacket() {} + +ConnectSuccessPacket::ConnectSuccessPacket( + ConnectionId clientId, Uuid serverUuid, CelestialBaseInformation celestialInformation) + : clientId(clientId), serverUuid(move(serverUuid)), celestialInformation(move(celestialInformation)) {} + +void ConnectSuccessPacket::read(DataStream& ds) { + ds.vuread(clientId); + ds.read(serverUuid); + ds.read(celestialInformation); +} + +void ConnectSuccessPacket::write(DataStream& ds) const { + ds.vuwrite(clientId); + ds.write(serverUuid); + ds.write(celestialInformation); +} + +ConnectFailurePacket::ConnectFailurePacket() {} + +ConnectFailurePacket::ConnectFailurePacket(String reason) : reason(move(reason)) {} + +void ConnectFailurePacket::read(DataStream& ds) { + ds.read(reason); +} + +void ConnectFailurePacket::write(DataStream& ds) const { + ds.write(reason); +} + +HandshakeChallengePacket::HandshakeChallengePacket() {} + +HandshakeChallengePacket::HandshakeChallengePacket(ByteArray const& passwordSalt) : passwordSalt(passwordSalt) {} + +void HandshakeChallengePacket::read(DataStream& ds) { + ds.read(passwordSalt); +} + +void HandshakeChallengePacket::write(DataStream& ds) const { + ds.write(passwordSalt); +} + +ChatReceivePacket::ChatReceivePacket() {} + +ChatReceivePacket::ChatReceivePacket(ChatReceivedMessage receivedMessage) : receivedMessage(receivedMessage) {} + +void ChatReceivePacket::read(DataStream& ds) { + ds.read(receivedMessage); +} + +void ChatReceivePacket::write(DataStream& ds) const { + ds.write(receivedMessage); +} + +UniverseTimeUpdatePacket::UniverseTimeUpdatePacket() { + universeTime = 0; +} + +UniverseTimeUpdatePacket::UniverseTimeUpdatePacket(double universeTime) : universeTime(universeTime) {} + +void UniverseTimeUpdatePacket::read(DataStream& ds) { + ds.vfread(universeTime, 0.05); +} + +void UniverseTimeUpdatePacket::write(DataStream& ds) const { + ds.vfwrite(universeTime, 0.05); +} + +CelestialResponsePacket::CelestialResponsePacket() {} + +CelestialResponsePacket::CelestialResponsePacket(List<CelestialResponse> responses) : responses(move(responses)) {} + +void CelestialResponsePacket::read(DataStream& ds) { + ds.read(responses); +} + +void CelestialResponsePacket::write(DataStream& ds) const { + ds.write(responses); +} + +PlayerWarpResultPacket::PlayerWarpResultPacket() : warpActionInvalid(false) {} + +PlayerWarpResultPacket::PlayerWarpResultPacket(bool success, WarpAction warpAction, bool warpActionInvalid) + : success(success), warpAction(move(warpAction)), warpActionInvalid(warpActionInvalid) {} + +void PlayerWarpResultPacket::read(DataStream& ds) { + ds.read(success); + ds.read(warpAction); + ds.read(warpActionInvalid); +} + +void PlayerWarpResultPacket::write(DataStream& ds) const { + ds.write(success); + ds.write(warpAction); + ds.write(warpActionInvalid); +} + +PlanetTypeUpdatePacket::PlanetTypeUpdatePacket() {} + +PlanetTypeUpdatePacket::PlanetTypeUpdatePacket(CelestialCoordinate coordinate) + : coordinate(coordinate) {} + +void PlanetTypeUpdatePacket::read(DataStream& ds) { + ds.read(coordinate); +} + +void PlanetTypeUpdatePacket::write(DataStream& ds) const { + ds.write(coordinate); +} + +PausePacket::PausePacket() {} + +PausePacket::PausePacket(bool pause) : pause(move(pause)) {} + +void PausePacket::read(DataStream& ds) { + ds.read(pause); +} + +void PausePacket::write(DataStream& ds) const { + ds.write(pause); +} + +ServerInfoPacket::ServerInfoPacket() {} + +ServerInfoPacket::ServerInfoPacket(uint16_t players, uint16_t maxPlayers) : + players(players), + maxPlayers(maxPlayers) {} + +void ServerInfoPacket::read(DataStream& ds) +{ + ds.read(players); + ds.read(maxPlayers); +} + +void ServerInfoPacket::write(DataStream& ds) const +{ + ds.write(players); + ds.write(maxPlayers); +} + +ClientConnectPacket::ClientConnectPacket() {} + +ClientConnectPacket::ClientConnectPacket(ByteArray assetsDigest, bool allowAssetsMismatch, Uuid playerUuid, + String playerName, String playerSpecies, WorldChunks shipChunks, ShipUpgrades shipUpgrades, + bool introComplete, String account) + : assetsDigest(move(assetsDigest)), allowAssetsMismatch(allowAssetsMismatch), playerUuid(move(playerUuid)), + playerName(move(playerName)), playerSpecies(move(playerSpecies)), shipChunks(move(shipChunks)), + shipUpgrades(move(shipUpgrades)), introComplete(move(introComplete)), account(move(account)) {} + +void ClientConnectPacket::read(DataStream& ds) { + ds.read(assetsDigest); + ds.read(allowAssetsMismatch); + ds.read(playerUuid); + ds.read(playerName); + ds.read(playerSpecies); + ds.read(shipChunks); + ds.read(shipUpgrades); + ds.read(introComplete); + ds.read(account); +} + +void ClientConnectPacket::write(DataStream& ds) const { + ds.write(assetsDigest); + ds.write(allowAssetsMismatch); + ds.write(playerUuid); + ds.write(playerName); + ds.write(playerSpecies); + ds.write(shipChunks); + ds.write(shipUpgrades); + ds.write(introComplete); + ds.write(account); +} + +ClientDisconnectRequestPacket::ClientDisconnectRequestPacket() {} + +void ClientDisconnectRequestPacket::read(DataStream& ds) { + // Packets cannot be empty due to the way packet serialization is handled. + ds.read<uint8_t>(); +} + +void ClientDisconnectRequestPacket::write(DataStream& ds) const { + // Packets cannot be empty due to the way packet serialization is handled. + ds.write<uint8_t>(0); +} + +HandshakeResponsePacket::HandshakeResponsePacket() {} + +HandshakeResponsePacket::HandshakeResponsePacket(ByteArray const& passHash) : passHash(passHash) {} + +void HandshakeResponsePacket::read(DataStream& ds) { + ds.read(passHash); +} + +void HandshakeResponsePacket::write(DataStream& ds) const { + ds.write(passHash); +} + +PlayerWarpPacket::PlayerWarpPacket() {} + +PlayerWarpPacket::PlayerWarpPacket(WarpAction action, bool deploy) : action(move(action)), deploy(move(deploy)) {} + +void PlayerWarpPacket::read(DataStream& ds) { + ds.read(action); + ds.read(deploy); +} + +void PlayerWarpPacket::write(DataStream& ds) const { + ds.write(action); + ds.write(deploy); +} + +FlyShipPacket::FlyShipPacket() {} + +FlyShipPacket::FlyShipPacket(Vec3I system, SystemLocation location) : system(move(system)), location(move(location)) {} + +void FlyShipPacket::read(DataStream& ds) { + ds.read(system); + ds.read(location); +} + +void FlyShipPacket::write(DataStream& ds) const { + ds.write(system); + ds.write(location); +} + +ChatSendPacket::ChatSendPacket() : sendMode(ChatSendMode::Broadcast) {} + +ChatSendPacket::ChatSendPacket(String text, ChatSendMode sendMode) : text(move(text)), sendMode(sendMode) {} + +void ChatSendPacket::read(DataStream& ds) { + ds.read(text); + ds.read(sendMode); +} + +void ChatSendPacket::write(DataStream& ds) const { + ds.write(text); + ds.write(sendMode); +} + +CelestialRequestPacket::CelestialRequestPacket() {} + +CelestialRequestPacket::CelestialRequestPacket(List<CelestialRequest> requests) : requests(move(requests)) {} + +void CelestialRequestPacket::read(DataStream& ds) { + ds.read(requests); +} + +void CelestialRequestPacket::write(DataStream& ds) const { + ds.write(requests); +} + +ClientContextUpdatePacket::ClientContextUpdatePacket() {} + +ClientContextUpdatePacket::ClientContextUpdatePacket(ByteArray updateData) : updateData(move(updateData)) {} + +void ClientContextUpdatePacket::read(DataStream& ds) { + ds.read(updateData); +} + +void ClientContextUpdatePacket::write(DataStream& ds) const { + ds.write(updateData); +} + +WorldStartPacket::WorldStartPacket() : clientId(), localInterpolationMode() {} + +void WorldStartPacket::read(DataStream& ds) { + ds.read(templateData); + ds.read(skyData); + ds.read(weatherData); + ds.read(playerStart); + ds.read(playerRespawn); + ds.read(respawnInWorld); + ds.read(worldProperties); + ds.read(dungeonIdGravity); + ds.read(dungeonIdBreathable); + ds.read(protectedDungeonIds); + ds.read(clientId); + ds.read(localInterpolationMode); +} + +void WorldStartPacket::write(DataStream& ds) const { + ds.write(templateData); + ds.write(skyData); + ds.write(weatherData); + ds.write(playerStart); + ds.write(playerRespawn); + ds.write(respawnInWorld); + ds.write(worldProperties); + ds.write(dungeonIdGravity); + ds.write(dungeonIdBreathable); + ds.write(protectedDungeonIds); + ds.write(clientId); + ds.write(localInterpolationMode); +} + +WorldStopPacket::WorldStopPacket() {} + +WorldStopPacket::WorldStopPacket(String const& reason) : reason(reason) {} + +void WorldStopPacket::read(DataStream& ds) { + ds.read(reason); +} + +void WorldStopPacket::write(DataStream& ds) const { + ds.write(reason); +} + +WorldLayoutUpdatePacket::WorldLayoutUpdatePacket() {} + +WorldLayoutUpdatePacket::WorldLayoutUpdatePacket(Json const& layoutData) : layoutData(layoutData) {} + +void WorldLayoutUpdatePacket::read(DataStream& ds) { + ds.read(layoutData); +} + +void WorldLayoutUpdatePacket::write(DataStream& ds) const { + ds.write(layoutData); +} + +WorldParametersUpdatePacket::WorldParametersUpdatePacket() {} + +WorldParametersUpdatePacket::WorldParametersUpdatePacket(ByteArray const& parametersData) : parametersData(parametersData) {} + +void WorldParametersUpdatePacket::read(DataStream& ds) { + ds.read(parametersData); +} + +void WorldParametersUpdatePacket::write(DataStream& ds) const { + ds.write(parametersData); +} + +CentralStructureUpdatePacket::CentralStructureUpdatePacket() {} + +CentralStructureUpdatePacket::CentralStructureUpdatePacket(Json structureData) : structureData(move(structureData)) {} + +void CentralStructureUpdatePacket::read(DataStream& ds) { + ds.read(structureData); +} + +void CentralStructureUpdatePacket::write(DataStream& ds) const { + ds.write(structureData); +} + +TileArrayUpdatePacket::TileArrayUpdatePacket() {} + +void TileArrayUpdatePacket::read(DataStream& ds) { + ds.viread(min[0]); + ds.viread(min[1]); + + size_t width, height; + ds.vuread(width); + ds.vuread(height); + array.resize(width, height); + for (size_t y = 0; y < height; ++y) { + for (size_t x = 0; x < width; ++x) + ds.read(array(x, y)); + } +} + +void TileArrayUpdatePacket::write(DataStream& ds) const { + ds.viwrite(min[0]); + ds.viwrite(min[1]); + ds.vuwrite(array.size(0)); + ds.vuwrite(array.size(1)); + for (size_t y = 0; y < array.size(1); ++y) { + for (size_t x = 0; x < array.size(0); ++x) + ds.write(array(x, y)); + } +} + +void TileUpdatePacket::read(DataStream& ds) { + ds.viread(position[0]); + ds.viread(position[1]); + ds.read(tile); +} + +void TileUpdatePacket::write(DataStream& ds) const { + ds.viwrite(position[0]); + ds.viwrite(position[1]); + ds.write(tile); +} + +TileLiquidUpdatePacket::TileLiquidUpdatePacket() {} + +TileLiquidUpdatePacket::TileLiquidUpdatePacket(Vec2I const& position, LiquidNetUpdate liquidUpdate) + : position(position), liquidUpdate(liquidUpdate) {} + +void TileLiquidUpdatePacket::read(DataStream& ds) { + ds.viread(position[0]); + ds.viread(position[1]); + ds.read(liquidUpdate.liquid); + ds.read(liquidUpdate.level); +} + +void TileLiquidUpdatePacket::write(DataStream& ds) const { + ds.viwrite(position[0]); + ds.viwrite(position[1]); + ds.write(liquidUpdate.liquid); + ds.write(liquidUpdate.level); +} + +TileDamageUpdatePacket::TileDamageUpdatePacket() : layer(TileLayer::Foreground) {} + +TileDamageUpdatePacket::TileDamageUpdatePacket( + Vec2I const& position, TileLayer layer, TileDamageStatus const& tileDamage) + : position(position), layer(layer), tileDamage(tileDamage) {} + +void TileDamageUpdatePacket::read(DataStream& ds) { + ds.read(position); + ds.read(layer); + ds.read(tileDamage); +} + +void TileDamageUpdatePacket::write(DataStream& ds) const { + ds.write(position); + ds.write(layer); + ds.write(tileDamage); +} + +TileModificationFailurePacket::TileModificationFailurePacket() {} + +TileModificationFailurePacket::TileModificationFailurePacket(TileModificationList modifications) + : modifications(modifications) {} + +void TileModificationFailurePacket::read(DataStream& ds) { + ds.readContainer(modifications); +} + +void TileModificationFailurePacket::write(DataStream& ds) const { + ds.writeContainer(modifications); +} + +GiveItemPacket::GiveItemPacket() {} + +GiveItemPacket::GiveItemPacket(ItemDescriptor const& item) : item(item) {} + +void GiveItemPacket::read(DataStream& ds) { + ds.read(item); +} + +void GiveItemPacket::write(DataStream& ds) const { + ds.write(item); +} + +EnvironmentUpdatePacket::EnvironmentUpdatePacket() {} + +EnvironmentUpdatePacket::EnvironmentUpdatePacket(ByteArray skyDelta, ByteArray weatherDelta) + : skyDelta(move(skyDelta)), weatherDelta(move(weatherDelta)) {} + +void EnvironmentUpdatePacket::read(DataStream& ds) { + ds.read(skyDelta); + ds.read(weatherDelta); +} + +void EnvironmentUpdatePacket::write(DataStream& ds) const { + ds.write(skyDelta); + ds.write(weatherDelta); +} + +ModifyTileListPacket::ModifyTileListPacket() : allowEntityOverlap() {} + +ModifyTileListPacket::ModifyTileListPacket(TileModificationList modifications, bool allowEntityOverlap) + : modifications(modifications), allowEntityOverlap(allowEntityOverlap) {} + +void ModifyTileListPacket::read(DataStream& ds) { + ds.readContainer(modifications); + ds.read(allowEntityOverlap); +} + +void ModifyTileListPacket::write(DataStream& ds) const { + ds.writeContainer(modifications); + ds.write(allowEntityOverlap); +} + +DamageTileGroupPacket::DamageTileGroupPacket() : layer(TileLayer::Foreground) {} + +DamageTileGroupPacket::DamageTileGroupPacket( + List<Vec2I> tilePositions, TileLayer layer, Vec2F sourcePosition, TileDamage tileDamage, Maybe<EntityId> sourceEntity) + : tilePositions(move(tilePositions)), layer(layer), sourcePosition(sourcePosition), tileDamage(move(tileDamage)), sourceEntity(move(sourceEntity)) {} + +void DamageTileGroupPacket::read(DataStream& ds) { + ds.readContainer(tilePositions); + ds.read(layer); + ds.read(sourcePosition); + ds.read(tileDamage); + ds.read(sourceEntity); +} + +void DamageTileGroupPacket::write(DataStream& ds) const { + ds.writeContainer(tilePositions); + ds.write(layer); + ds.write(sourcePosition); + ds.write(tileDamage); + ds.write(sourceEntity); +} + +CollectLiquidPacket::CollectLiquidPacket() {} + +CollectLiquidPacket::CollectLiquidPacket(List<Vec2I> tilePositions, LiquidId liquidId) + : tilePositions(move(tilePositions)), liquidId(liquidId) {} + +void CollectLiquidPacket::read(DataStream& ds) { + ds.readContainer(tilePositions); + ds.read(liquidId); +} + +void CollectLiquidPacket::write(DataStream& ds) const { + ds.writeContainer(tilePositions); + ds.write(liquidId); +} + +RequestDropPacket::RequestDropPacket() { + dropEntityId = NullEntityId; +} + +RequestDropPacket::RequestDropPacket(EntityId dropEntityId) : dropEntityId(dropEntityId) {} + +void RequestDropPacket::read(DataStream& ds) { + ds.viread(dropEntityId); +} + +void RequestDropPacket::write(DataStream& ds) const { + ds.viwrite(dropEntityId); +} + +SpawnEntityPacket::SpawnEntityPacket() {} + +SpawnEntityPacket::SpawnEntityPacket(EntityType entityType, ByteArray storeData, ByteArray firstNetState) + : entityType(entityType), storeData(move(storeData)), firstNetState(move(firstNetState)) {} + +void SpawnEntityPacket::read(DataStream& ds) { + ds.read(entityType); + ds.read(storeData); + ds.read(firstNetState); +} + +void SpawnEntityPacket::write(DataStream& ds) const { + ds.write(entityType); + ds.write(storeData); + ds.write(firstNetState); +} + +EntityInteractPacket::EntityInteractPacket() {} + +EntityInteractPacket::EntityInteractPacket(InteractRequest interactRequest, Uuid requestId) + : interactRequest(interactRequest), requestId(requestId) {} + +void EntityInteractPacket::read(DataStream& ds) { + ds.read(interactRequest); + ds.read(requestId); +} + +void EntityInteractPacket::write(DataStream& ds) const { + ds.write(interactRequest); + ds.write(requestId); +} + +EntityInteractResultPacket::EntityInteractResultPacket() {} + +EntityInteractResultPacket::EntityInteractResultPacket(InteractAction action, Uuid requestId, EntityId sourceEntityId) + : action(action), requestId(requestId), sourceEntityId(sourceEntityId) {} + +void EntityInteractResultPacket::read(DataStream& ds) { + ds.read(action); + ds.read(requestId); + ds.read(sourceEntityId); +} + +void EntityInteractResultPacket::write(DataStream& ds) const { + ds.write(action); + ds.write(requestId); + ds.write(sourceEntityId); +} + +EntityCreatePacket::EntityCreatePacket() { + entityId = NullEntityId; +} + +ServerDisconnectPacket::ServerDisconnectPacket() {} + +ServerDisconnectPacket::ServerDisconnectPacket(String reason) : reason(move(reason)) {} + +void ServerDisconnectPacket::read(DataStream& ds) { + ds.read(reason); +} + +void ServerDisconnectPacket::write(DataStream& ds) const { + ds.write(reason); +} + +ConnectWirePacket::ConnectWirePacket() {} + +ConnectWirePacket::ConnectWirePacket(WireConnection outputConnection, WireConnection inputConnection) + : outputConnection(outputConnection), inputConnection(inputConnection) {} + +void ConnectWirePacket::read(DataStream& ds) { + ds.read(outputConnection); + ds.read(inputConnection); +} + +void ConnectWirePacket::write(DataStream& ds) const { + ds.write(outputConnection); + ds.write(inputConnection); +} + +DisconnectAllWiresPacket::DisconnectAllWiresPacket() {} + +DisconnectAllWiresPacket::DisconnectAllWiresPacket(Vec2I entityPosition, WireNode wireNode) + : entityPosition(entityPosition), wireNode(wireNode) {} + +void DisconnectAllWiresPacket::read(DataStream& ds) { + ds.viread(entityPosition[0]); + ds.viread(entityPosition[1]); + ds.read(wireNode); +} + +void DisconnectAllWiresPacket::write(DataStream& ds) const { + ds.viwrite(entityPosition[0]); + ds.viwrite(entityPosition[1]); + ds.write(wireNode); +} + +WorldClientStateUpdatePacket::WorldClientStateUpdatePacket() {} + +WorldClientStateUpdatePacket::WorldClientStateUpdatePacket(ByteArray const& worldClientStateDelta) + : worldClientStateDelta(worldClientStateDelta) {} + +void WorldClientStateUpdatePacket::read(DataStream& ds) { + ds.read(worldClientStateDelta); +} + +void WorldClientStateUpdatePacket::write(DataStream& ds) const { + ds.write(worldClientStateDelta); +} + +FindUniqueEntityPacket::FindUniqueEntityPacket() {} + +FindUniqueEntityPacket::FindUniqueEntityPacket(String uniqueEntityId) + : uniqueEntityId(move(uniqueEntityId)) {} + +void FindUniqueEntityPacket::read(DataStream& ds) { + ds.read(uniqueEntityId); +} + +void FindUniqueEntityPacket::write(DataStream& ds) const { + ds.write(uniqueEntityId); +} + +WorldStartAcknowledgePacket::WorldStartAcknowledgePacket() {} + +void WorldStartAcknowledgePacket::read(DataStream& ds) { + // Packets can't be empty, read the trash data + ds.read<bool>(); +} + +void WorldStartAcknowledgePacket::write(DataStream& ds) const { + // Packets can't be empty, write some trash data + ds.write<bool>(false); +} + +PingPacket::PingPacket() {} + +void PingPacket::read(DataStream& ds) { + // Packets can't be empty, read the trash data + ds.read<bool>(); +} + +void PingPacket::write(DataStream& ds) const { + // Packets can't be empty, write some trash data + ds.write(false); +} + +EntityCreatePacket::EntityCreatePacket(EntityType entityType, ByteArray storeData, ByteArray firstNetState, EntityId entityId) + : entityType(entityType), storeData(move(storeData)), firstNetState(move(firstNetState)), entityId(entityId) {} + +void EntityCreatePacket::read(DataStream& ds) { + ds.read(entityType); + ds.read(storeData); + ds.read(firstNetState); + ds.viread(entityId); +} + +void EntityCreatePacket::write(DataStream& ds) const { + ds.write(entityType); + ds.write(storeData); + ds.write(firstNetState); + ds.viwrite(entityId); +} + +EntityUpdateSetPacket::EntityUpdateSetPacket(ConnectionId forConnection) : forConnection(forConnection) {} + +void EntityUpdateSetPacket::read(DataStream& ds) { + ds.vuread(forConnection); + ds.readMapContainer(deltas, + [](DataStream& ds, EntityId& entityId, ByteArray& delta) { + ds.viread(entityId); + ds.read(delta); + }); +} + +void EntityUpdateSetPacket::write(DataStream& ds) const { + ds.vuwrite(forConnection); + ds.writeMapContainer(deltas, [](DataStream& ds, EntityId const& entityId, ByteArray const& delta) { + ds.viwrite(entityId); + ds.write(delta); + }); +} + +EntityDestroyPacket::EntityDestroyPacket() { + entityId = NullEntityId; + death = false; +} + +EntityDestroyPacket::EntityDestroyPacket(EntityId entityId, ByteArray finalNetState, bool death) + : entityId(entityId), finalNetState(move(finalNetState)), death(death) {} + +void EntityDestroyPacket::read(DataStream& ds) { + ds.viread(entityId); + ds.read(finalNetState); + ds.read(death); +} + +void EntityDestroyPacket::write(DataStream& ds) const { + ds.viwrite(entityId); + ds.write(finalNetState); + ds.write(death); +} + +HitRequestPacket::HitRequestPacket() {} + +HitRequestPacket::HitRequestPacket(RemoteHitRequest remoteHitRequest) : remoteHitRequest(move(remoteHitRequest)) {} + +void HitRequestPacket::read(DataStream& ds) { + ds.read(remoteHitRequest); +} + +void HitRequestPacket::write(DataStream& ds) const { + ds.write(remoteHitRequest); +} + +DamageRequestPacket::DamageRequestPacket() {} + +DamageRequestPacket::DamageRequestPacket(RemoteDamageRequest remoteDamageRequest) + : remoteDamageRequest(move(remoteDamageRequest)) {} + +void DamageRequestPacket::read(DataStream& ds) { + ds.read(remoteDamageRequest); +} + +void DamageRequestPacket::write(DataStream& ds) const { + ds.write(remoteDamageRequest); +} + +DamageNotificationPacket::DamageNotificationPacket() {} + +DamageNotificationPacket::DamageNotificationPacket(RemoteDamageNotification remoteDamageNotification) + : remoteDamageNotification(move(remoteDamageNotification)) {} + +void DamageNotificationPacket::read(DataStream& ds) { + ds.read(remoteDamageNotification); +} + +void DamageNotificationPacket::write(DataStream& ds) const { + ds.write(remoteDamageNotification); +} + +EntityMessagePacket::EntityMessagePacket() {} + +EntityMessagePacket::EntityMessagePacket(Variant<EntityId, String> entityId, String message, JsonArray args, Uuid uuid, ConnectionId fromConnection) + : entityId(entityId), message(move(message)), args(move(args)), uuid(uuid), fromConnection(fromConnection) {} + +void EntityMessagePacket::read(DataStream& ds) { + ds.read(entityId); + ds.read(message); + ds.read(args); + ds.read(uuid); + ds.read(fromConnection); +} + +void EntityMessagePacket::write(DataStream& ds) const { + ds.write(entityId); + ds.write(message); + ds.write(args); + ds.write(uuid); + ds.write(fromConnection); +} + +EntityMessageResponsePacket::EntityMessageResponsePacket() {} + +EntityMessageResponsePacket::EntityMessageResponsePacket(Either<String, Json> response, Uuid uuid) + : response(move(response)), uuid(uuid) {} + +void EntityMessageResponsePacket::read(DataStream& ds) { + ds.read(response); + ds.read(uuid); +} + +void EntityMessageResponsePacket::write(DataStream& ds) const { + ds.write(response); + ds.write(uuid); +} + +UpdateWorldPropertiesPacket::UpdateWorldPropertiesPacket() {} + +UpdateWorldPropertiesPacket::UpdateWorldPropertiesPacket(JsonObject const& updatedProperties) + : updatedProperties(updatedProperties) {} + +void UpdateWorldPropertiesPacket::read(DataStream& ds) { + ds.readMapContainer(updatedProperties); +} + +void UpdateWorldPropertiesPacket::write(DataStream& ds) const { + ds.writeMapContainer(updatedProperties); +} + +UpdateTileProtectionPacket::UpdateTileProtectionPacket() {} + +UpdateTileProtectionPacket::UpdateTileProtectionPacket(DungeonId dungeonId, bool isProtected) + : dungeonId(dungeonId), isProtected(isProtected) {} + +void UpdateTileProtectionPacket::read(DataStream& ds) { + ds.read(dungeonId); + ds.read(isProtected); +} + +void UpdateTileProtectionPacket::write(DataStream& ds) const { + ds.write(dungeonId); + ds.write(isProtected); +} + +SetDungeonGravityPacket::SetDungeonGravityPacket() {} + +SetDungeonGravityPacket::SetDungeonGravityPacket(DungeonId dungeonId, Maybe<float> gravity) + : dungeonId(move(dungeonId)), gravity(move(gravity)) {} + +void SetDungeonGravityPacket::read(DataStream& ds) { + ds.read(dungeonId); + ds.read(gravity); +} + +void SetDungeonGravityPacket::write(DataStream& ds) const { + ds.write(dungeonId); + ds.write(gravity); +} + +SetDungeonBreathablePacket::SetDungeonBreathablePacket() {} + +SetDungeonBreathablePacket::SetDungeonBreathablePacket(DungeonId dungeonId, Maybe<bool> breathable) + : dungeonId(move(dungeonId)), breathable(move(breathable)) {} + +void SetDungeonBreathablePacket::read(DataStream& ds) { + ds.read(dungeonId); + ds.read(breathable); +} + +void SetDungeonBreathablePacket::write(DataStream& ds) const { + ds.write(dungeonId); + ds.write(breathable); +} + +SetPlayerStartPacket::SetPlayerStartPacket() {} + +SetPlayerStartPacket::SetPlayerStartPacket(Vec2F playerStart, bool respawnInWorld) : playerStart(playerStart), respawnInWorld(respawnInWorld) {} + +void SetPlayerStartPacket::read(DataStream& ds) { + ds.read(playerStart); + ds.read(respawnInWorld); +} + +void SetPlayerStartPacket::write(DataStream& ds) const { + ds.write(playerStart); + ds.write(respawnInWorld); +} + +FindUniqueEntityResponsePacket::FindUniqueEntityResponsePacket() {} + +FindUniqueEntityResponsePacket::FindUniqueEntityResponsePacket(String uniqueEntityId, Maybe<Vec2F> entityPosition) + : uniqueEntityId(move(uniqueEntityId)), entityPosition(move(entityPosition)) {} + +void FindUniqueEntityResponsePacket::read(DataStream& ds) { + ds.read(uniqueEntityId); + ds.read(entityPosition); +} + +void FindUniqueEntityResponsePacket::write(DataStream& ds) const { + ds.write(uniqueEntityId); + ds.write(entityPosition); +} + +PongPacket::PongPacket() {} + +void PongPacket::read(DataStream& ds) { + // Packets can't be empty, read the trash data + ds.read<bool>(); +} + +void PongPacket::write(DataStream& ds) const { + // Packets can't be empty, write some trash data + ds.write<bool>(false); +} + +StepUpdatePacket::StepUpdatePacket() : remoteStep(0) {} + +StepUpdatePacket::StepUpdatePacket(uint64_t remoteStep) : remoteStep(remoteStep) {} + +void StepUpdatePacket::read(DataStream& ds) { + ds.vuread(remoteStep); +} + +void StepUpdatePacket::write(DataStream& ds) const { + ds.vuwrite(remoteStep); +} + +SystemWorldStartPacket::SystemWorldStartPacket() {} + +SystemWorldStartPacket::SystemWorldStartPacket(Vec3I location, List<ByteArray> objectStores, List<ByteArray> shipStores, pair<Uuid, SystemLocation> clientShip) + : location(move(location)), objectStores(move(objectStores)), shipStores(move(shipStores)), clientShip(move(clientShip)) {} + +void SystemWorldStartPacket::read(DataStream& ds) { + ds.read(location); + ds.read(objectStores); + ds.read(shipStores); + ds.read(clientShip); +} + +void SystemWorldStartPacket::write(DataStream& ds) const { + ds.write(location); + ds.write(objectStores); + ds.write(shipStores); + ds.write(clientShip); +} + +SystemWorldUpdatePacket::SystemWorldUpdatePacket() {} + +SystemWorldUpdatePacket::SystemWorldUpdatePacket(HashMap<Uuid, ByteArray> objectUpdates, HashMap<Uuid, ByteArray> shipUpdates) + : objectUpdates(move(objectUpdates)), shipUpdates(move(shipUpdates)) {} + +void SystemWorldUpdatePacket::read(DataStream& ds) { + ds.read(objectUpdates); + ds.read(shipUpdates); +} + +void SystemWorldUpdatePacket::write(DataStream& ds) const { + ds.write(objectUpdates); + ds.write(shipUpdates); +} + +SystemObjectCreatePacket::SystemObjectCreatePacket() {} + +SystemObjectCreatePacket::SystemObjectCreatePacket(ByteArray objectStore) : objectStore(move(objectStore)) {} + +void SystemObjectCreatePacket::read(DataStream& ds) { + ds.read(objectStore); +} + +void SystemObjectCreatePacket::write(DataStream& ds) const { + ds.write(objectStore); +} + +SystemObjectDestroyPacket::SystemObjectDestroyPacket() {} + +SystemObjectDestroyPacket::SystemObjectDestroyPacket(Uuid objectUuid) : objectUuid(move(objectUuid)) {} + +void SystemObjectDestroyPacket::read(DataStream& ds) { + ds.read(objectUuid); +} + +void SystemObjectDestroyPacket::write(DataStream& ds) const { + ds.write(objectUuid); +} + +SystemShipCreatePacket::SystemShipCreatePacket() {} + +SystemShipCreatePacket::SystemShipCreatePacket(ByteArray shipStore) : shipStore(move(shipStore)) {} + +void SystemShipCreatePacket::read(DataStream& ds) { + ds.read(shipStore); +} + +void SystemShipCreatePacket::write(DataStream& ds) const { + ds.write(shipStore); +} + +SystemShipDestroyPacket::SystemShipDestroyPacket() {} + +SystemShipDestroyPacket::SystemShipDestroyPacket(Uuid shipUuid) : shipUuid(move(shipUuid)) {} + +void SystemShipDestroyPacket::read(DataStream& ds) { + ds.read(shipUuid); +} + +void SystemShipDestroyPacket::write(DataStream& ds) const { + ds.write(shipUuid); +} + +SystemObjectSpawnPacket::SystemObjectSpawnPacket() {} + +SystemObjectSpawnPacket::SystemObjectSpawnPacket(String typeName, Uuid uuid, Maybe<Vec2F> position, JsonObject parameters) + : typeName(move(typeName)), uuid(move(uuid)), position(move(position)), parameters(move(parameters)) {} + +void SystemObjectSpawnPacket::read(DataStream& ds) { + ds.read(typeName); + ds.read(uuid); + ds.read(position); + ds.read(parameters); +} + +void SystemObjectSpawnPacket::write(DataStream& ds) const { + ds.write(typeName); + ds.write(uuid); + ds.write(position); + ds.write(parameters); +} + +} |