osb/source/game/StarNetPackets.cpp

1265 lines
39 KiB
C++
Raw Normal View History

2023-06-20 04:33:09 +00:00
#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);
}
}