everything everywhere

all at once

1 files changed, 896 insertions, 0 deletions

diff --git a/source/game/StarNetPackets.hpp b/source/game/StarNetPackets.hpp
new file mode 100644
index 0000000..b97d53e
--- /dev/null
+++ b/source/game/StarNetPackets.hpp
@@ -0,0 +1,896 @@
+#ifndef STAR_NET_PACKETS_HPP
+#define STAR_NET_PACKETS_HPP
+
+#include "StarDataStream.hpp"
+#include "StarWorldTiles.hpp"
+#include "StarItemDescriptor.hpp"
+#include "StarCelestialDatabase.hpp"
+#include "StarDamageManager.hpp"
+#include "StarChatTypes.hpp"
+#include "StarUuid.hpp"
+#include "StarTileModification.hpp"
+#include "StarEntity.hpp"
+#include "StarInteractionTypes.hpp"
+#include "StarWarping.hpp"
+#include "StarWiring.hpp"
+#include "StarClientContext.hpp"
+#include "StarSystemWorld.hpp"
+
+namespace Star {
+
+STAR_STRUCT(Packet);
+
+STAR_EXCEPTION(StarPacketException, IOException);
+
+extern VersionNumber const StarProtocolVersion;
+
+// Packet types sent between the client and server over a NetSocket.  Does not
+// correspond to actual packets, simply logical portions of NetSocket data.
+enum class PacketType : uint8_t {
+  // Packets used as part of the initial handshake
+  ProtocolRequest,
+  ProtocolResponse,
+
+  // Packets sent universe server -> universe client
+  ServerDisconnect,
+  ConnectSuccess,
+  ConnectFailure,
+  HandshakeChallenge,
+  ChatReceive,
+  UniverseTimeUpdate,
+  CelestialResponse,
+  PlayerWarpResult,
+  PlanetTypeUpdate,
+  Pause,
+  ServerInfo,
+
+  // Packets sent universe client -> universe server
+  ClientConnect,
+  ClientDisconnectRequest,
+  HandshakeResponse,
+  PlayerWarp,
+  FlyShip,
+  ChatSend,
+  CelestialRequest,
+
+  // Packets sent bidirectionally between the universe client and the universe
+  // server
+  ClientContextUpdate,
+
+  // Packets sent world server -> world client
+  WorldStart,
+  WorldStop,
+  WorldLayoutUpdate,
+  WorldParametersUpdate,
+  CentralStructureUpdate,
+  TileArrayUpdate,
+  TileUpdate,
+  TileLiquidUpdate,
+  TileDamageUpdate,
+  TileModificationFailure,
+  GiveItem,
+  EnvironmentUpdate,
+  UpdateTileProtection,
+  SetDungeonGravity,
+  SetDungeonBreathable,
+  SetPlayerStart,
+  FindUniqueEntityResponse,
+  Pong,
+
+  // Packets sent world client -> world server
+  ModifyTileList,
+  DamageTileGroup,
+  CollectLiquid,
+  RequestDrop,
+  SpawnEntity,
+  ConnectWire,
+  DisconnectAllWires,
+  WorldClientStateUpdate,
+  FindUniqueEntity,
+  WorldStartAcknowledge,
+  Ping,
+
+  // Packets sent bidirectionally between world client and world server
+  EntityCreate,
+  EntityUpdateSet,
+  EntityDestroy,
+  EntityInteract,
+  EntityInteractResult,
+  HitRequest,
+  DamageRequest,
+  DamageNotification,
+  EntityMessage,
+  EntityMessageResponse,
+  UpdateWorldProperties,
+  StepUpdate,
+
+  // Packets sent system server -> system client
+  SystemWorldStart,
+  SystemWorldUpdate,
+  SystemObjectCreate,
+  SystemObjectDestroy,
+  SystemShipCreate,
+  SystemShipDestroy,
+
+  // Packets sent system client -> system server
+  SystemObjectSpawn
+};
+extern EnumMap<PacketType> const PacketTypeNames;
+
+struct Packet {
+  virtual ~Packet();
+
+  virtual PacketType type() const = 0;
+
+  virtual void read(DataStream& ds) = 0;
+  virtual void write(DataStream& ds) const = 0;
+};
+
+PacketPtr createPacket(PacketType type);
+
+template <PacketType PacketT>
+struct PacketBase : public Packet {
+  static PacketType const Type = PacketT;
+
+  PacketType type() const override {
+    return Type;
+  }
+};
+
+struct ProtocolRequestPacket : PacketBase<PacketType::ProtocolRequest> {
+  ProtocolRequestPacket();
+  ProtocolRequestPacket(VersionNumber requestProtocolVersion);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  VersionNumber requestProtocolVersion;
+};
+
+struct ProtocolResponsePacket : PacketBase<PacketType::ProtocolResponse> {
+  ProtocolResponsePacket(bool allowed = false);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  bool allowed;
+};
+
+struct ServerDisconnectPacket : PacketBase<PacketType::ServerDisconnect> {
+  ServerDisconnectPacket();
+  ServerDisconnectPacket(String reason);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  String reason;
+};
+
+struct ConnectSuccessPacket : PacketBase<PacketType::ConnectSuccess> {
+  ConnectSuccessPacket();
+  ConnectSuccessPacket(ConnectionId clientId, Uuid serverUuid, CelestialBaseInformation celestialInformation);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ConnectionId clientId;
+  Uuid serverUuid;
+  CelestialBaseInformation celestialInformation;
+};
+
+struct ConnectFailurePacket : PacketBase<PacketType::ConnectFailure> {
+  ConnectFailurePacket();
+  ConnectFailurePacket(String reason);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  String reason;
+};
+
+struct HandshakeChallengePacket : PacketBase<PacketType::HandshakeChallenge> {
+  HandshakeChallengePacket();
+  HandshakeChallengePacket(ByteArray const& passwordSalt);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ByteArray passwordSalt;
+};
+
+struct ChatReceivePacket : PacketBase<PacketType::ChatReceive> {
+  ChatReceivePacket();
+  ChatReceivePacket(ChatReceivedMessage receivedMessage);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ChatReceivedMessage receivedMessage;
+};
+
+struct UniverseTimeUpdatePacket : PacketBase<PacketType::UniverseTimeUpdate> {
+  UniverseTimeUpdatePacket();
+  UniverseTimeUpdatePacket(double universeTime);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  double universeTime;
+};
+
+struct CelestialResponsePacket : PacketBase<PacketType::CelestialResponse> {
+  CelestialResponsePacket();
+  CelestialResponsePacket(List<CelestialResponse> responses);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  List<CelestialResponse> responses;
+};
+
+struct PlayerWarpResultPacket : PacketBase<PacketType::PlayerWarpResult> {
+  PlayerWarpResultPacket();
+  PlayerWarpResultPacket(bool success, WarpAction warpAction, bool warpActionInvalid);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  bool success;
+  WarpAction warpAction;
+  bool warpActionInvalid;
+};
+
+struct PlanetTypeUpdatePacket : PacketBase<PacketType::PlanetTypeUpdate> {
+  PlanetTypeUpdatePacket();
+  PlanetTypeUpdatePacket(CelestialCoordinate coordinate);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  CelestialCoordinate coordinate;
+};
+
+struct PausePacket : PacketBase<PacketType::Pause> {
+  PausePacket();
+  PausePacket(bool pause);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  bool pause;
+};
+
+struct ServerInfoPacket : PacketBase<PacketType::ServerInfo> {
+  ServerInfoPacket();
+  ServerInfoPacket(uint16_t players, uint16_t maxPlayers);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  uint16_t players;
+  uint16_t maxPlayers;
+};
+
+struct ClientConnectPacket : PacketBase<PacketType::ClientConnect> {
+  ClientConnectPacket();
+  ClientConnectPacket(ByteArray assetsDigest, bool allowAssetsMismatch, Uuid playerUuid, String playerName,
+      String playerSpecies, WorldChunks shipChunks, ShipUpgrades shipUpgrades, bool introComplete,
+      String account);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ByteArray assetsDigest;
+  bool allowAssetsMismatch;
+  Uuid playerUuid;
+  String playerName;
+  String playerSpecies;
+  WorldChunks shipChunks;
+  ShipUpgrades shipUpgrades;
+  bool introComplete;
+  String account;
+};
+
+struct ClientDisconnectRequestPacket : PacketBase<PacketType::ClientDisconnectRequest> {
+  ClientDisconnectRequestPacket();
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+};
+
+struct HandshakeResponsePacket : PacketBase<PacketType::HandshakeResponse> {
+  HandshakeResponsePacket();
+  HandshakeResponsePacket(ByteArray const& passHash);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ByteArray passHash;
+};
+
+struct PlayerWarpPacket : PacketBase<PacketType::PlayerWarp> {
+  PlayerWarpPacket();
+  PlayerWarpPacket(WarpAction action, bool deploy);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  WarpAction action;
+  bool deploy;
+};
+
+struct FlyShipPacket : PacketBase<PacketType::FlyShip> {
+  FlyShipPacket();
+  FlyShipPacket(Vec3I system, SystemLocation location);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Vec3I system;
+  SystemLocation location;
+};
+
+struct ChatSendPacket : PacketBase<PacketType::ChatSend> {
+  ChatSendPacket();
+  ChatSendPacket(String text, ChatSendMode sendMode);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  String text;
+  ChatSendMode sendMode;
+};
+
+struct CelestialRequestPacket : PacketBase<PacketType::CelestialRequest> {
+  CelestialRequestPacket();
+  CelestialRequestPacket(List<CelestialRequest> requests);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  List<CelestialRequest> requests;
+};
+
+struct ClientContextUpdatePacket : PacketBase<PacketType::ClientContextUpdate> {
+  ClientContextUpdatePacket();
+  ClientContextUpdatePacket(ByteArray updateData);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ByteArray updateData;
+};
+
+// Sent when a client should initialize themselves on a new world
+struct WorldStartPacket : PacketBase<PacketType::WorldStart> {
+  WorldStartPacket();
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Json templateData;
+  ByteArray skyData;
+  ByteArray weatherData;
+  Vec2F playerStart;
+  Vec2F playerRespawn;
+  bool respawnInWorld;
+  HashMap<DungeonId, float> dungeonIdGravity;
+  HashMap<DungeonId, bool> dungeonIdBreathable;
+  Set<DungeonId> protectedDungeonIds;
+  Json worldProperties;
+  ConnectionId clientId;
+  bool localInterpolationMode;
+};
+
+// Sent when a client is leaving a world
+struct WorldStopPacket : PacketBase<PacketType::WorldStop> {
+  WorldStopPacket();
+  WorldStopPacket(String const& reason);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  String reason;
+};
+
+// Sent when the region data for the client's current world changes
+struct WorldLayoutUpdatePacket : PacketBase<PacketType::WorldLayoutUpdate> {
+  WorldLayoutUpdatePacket();
+  WorldLayoutUpdatePacket(Json const& layoutData);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Json layoutData;
+};
+
+// Sent when the environment status effect list for the client's current world changes
+struct WorldParametersUpdatePacket : PacketBase<PacketType::WorldParametersUpdate> {
+  WorldParametersUpdatePacket();
+  WorldParametersUpdatePacket(ByteArray const& parametersData);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ByteArray parametersData;
+};
+
+struct CentralStructureUpdatePacket : PacketBase<PacketType::CentralStructureUpdate> {
+  CentralStructureUpdatePacket();
+  CentralStructureUpdatePacket(Json structureData);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Json structureData;
+};
+
+struct TileArrayUpdatePacket : PacketBase<PacketType::TileArrayUpdate> {
+  typedef MultiArray<NetTile, 2> TileArray;
+
+  TileArrayUpdatePacket();
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Vec2I min;
+  TileArray array;
+};
+
+struct TileUpdatePacket : PacketBase<PacketType::TileUpdate> {
+  TileUpdatePacket() {}
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Vec2I position;
+  NetTile tile;
+};
+
+struct TileLiquidUpdatePacket : PacketBase<PacketType::TileLiquidUpdate> {
+  TileLiquidUpdatePacket();
+  TileLiquidUpdatePacket(Vec2I const& position, LiquidNetUpdate liquidUpdate);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Vec2I position;
+  LiquidNetUpdate liquidUpdate;
+};
+
+struct TileDamageUpdatePacket : PacketBase<PacketType::TileDamageUpdate> {
+  TileDamageUpdatePacket();
+  TileDamageUpdatePacket(Vec2I const& position, TileLayer layer, TileDamageStatus const& tileDamage);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Vec2I position;
+  TileLayer layer;
+
+  TileDamageStatus tileDamage;
+};
+
+struct TileModificationFailurePacket : PacketBase<PacketType::TileModificationFailure> {
+  TileModificationFailurePacket();
+  TileModificationFailurePacket(TileModificationList modifications);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  TileModificationList modifications;
+};
+
+struct GiveItemPacket : PacketBase<PacketType::GiveItem> {
+  GiveItemPacket();
+  GiveItemPacket(ItemDescriptor const& item);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ItemDescriptor item;
+};
+
+struct EnvironmentUpdatePacket : PacketBase<PacketType::EnvironmentUpdate> {
+  EnvironmentUpdatePacket();
+  EnvironmentUpdatePacket(ByteArray skyDelta, ByteArray weatherDelta);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ByteArray skyDelta;
+  ByteArray weatherDelta;
+};
+
+struct UpdateTileProtectionPacket : PacketBase<PacketType::UpdateTileProtection> {
+  UpdateTileProtectionPacket();
+  UpdateTileProtectionPacket(DungeonId dungeonId, bool isProtected);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  DungeonId dungeonId;
+  bool isProtected;
+};
+
+struct SetDungeonGravityPacket : PacketBase<PacketType::SetDungeonGravity> {
+  SetDungeonGravityPacket();
+  SetDungeonGravityPacket(DungeonId dungeonId, Maybe<float> gravity);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  DungeonId dungeonId;
+  Maybe<float> gravity;
+};
+
+struct SetDungeonBreathablePacket : PacketBase<PacketType::SetDungeonBreathable> {
+  SetDungeonBreathablePacket();
+  SetDungeonBreathablePacket(DungeonId dungeonId, Maybe<bool> breathable);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  DungeonId dungeonId;
+  Maybe<bool> breathable;
+};
+
+struct SetPlayerStartPacket : PacketBase<PacketType::SetPlayerStart> {
+  SetPlayerStartPacket();
+  SetPlayerStartPacket(Vec2F playerStart, bool respawnInWorld);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Vec2F playerStart;
+  bool respawnInWorld;
+};
+
+struct FindUniqueEntityResponsePacket : PacketBase<PacketType::FindUniqueEntityResponse> {
+  FindUniqueEntityResponsePacket();
+  FindUniqueEntityResponsePacket(String uniqueEntityId, Maybe<Vec2F> entityPosition);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  String uniqueEntityId;
+  Maybe<Vec2F> entityPosition;
+};
+
+struct PongPacket : PacketBase<PacketType::Pong> {
+  PongPacket();
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+};
+
+struct ModifyTileListPacket : PacketBase<PacketType::ModifyTileList> {
+  ModifyTileListPacket();
+  ModifyTileListPacket(TileModificationList modifications, bool allowEntityOverlap);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  TileModificationList modifications;
+  bool allowEntityOverlap;
+};
+
+struct DamageTileGroupPacket : PacketBase<PacketType::DamageTileGroup> {
+  DamageTileGroupPacket();
+  DamageTileGroupPacket(List<Vec2I> tilePositions, TileLayer layer, Vec2F sourcePosition, TileDamage tileDamage, Maybe<EntityId> sourceEntity);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  List<Vec2I> tilePositions;
+  TileLayer layer;
+  Vec2F sourcePosition;
+  TileDamage tileDamage;
+  Maybe<EntityId> sourceEntity;
+};
+
+struct CollectLiquidPacket : PacketBase<PacketType::CollectLiquid> {
+  CollectLiquidPacket();
+  CollectLiquidPacket(List<Vec2I> tilePositions, LiquidId liquidId);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  List<Vec2I> tilePositions;
+  LiquidId liquidId;
+};
+
+struct RequestDropPacket : PacketBase<PacketType::RequestDrop> {
+  RequestDropPacket();
+  RequestDropPacket(EntityId dropEntityId);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  EntityId dropEntityId;
+};
+
+struct SpawnEntityPacket : PacketBase<PacketType::SpawnEntity> {
+  SpawnEntityPacket();
+  SpawnEntityPacket(EntityType entityType, ByteArray storeData, ByteArray firstNetState);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  EntityType entityType;
+  ByteArray storeData;
+  ByteArray firstNetState;
+};
+
+struct ConnectWirePacket : PacketBase<PacketType::ConnectWire> {
+  ConnectWirePacket();
+  ConnectWirePacket(WireConnection outputConnection, WireConnection inputConnection);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  WireConnection outputConnection;
+  WireConnection inputConnection;
+};
+
+struct DisconnectAllWiresPacket : PacketBase<PacketType::DisconnectAllWires> {
+  DisconnectAllWiresPacket();
+  DisconnectAllWiresPacket(Vec2I entityPosition, WireNode wireNode);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Vec2I entityPosition;
+  WireNode wireNode;
+};
+
+struct WorldClientStateUpdatePacket : PacketBase<PacketType::WorldClientStateUpdate> {
+  WorldClientStateUpdatePacket();
+  WorldClientStateUpdatePacket(ByteArray const& worldClientStateDelta);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ByteArray worldClientStateDelta;
+};
+
+struct FindUniqueEntityPacket : PacketBase<PacketType::FindUniqueEntity> {
+  FindUniqueEntityPacket();
+  FindUniqueEntityPacket(String uniqueEntityId);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  String uniqueEntityId;
+};
+
+struct WorldStartAcknowledgePacket : PacketBase<PacketType::WorldStartAcknowledge> {
+  WorldStartAcknowledgePacket();
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+};
+  
+struct PingPacket : PacketBase<PacketType::Ping> {
+  PingPacket();
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+};
+
+struct EntityCreatePacket : PacketBase<PacketType::EntityCreate> {
+  EntityCreatePacket();
+  EntityCreatePacket(EntityType entityType, ByteArray storeData, ByteArray firstNetState, EntityId entityId);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  EntityType entityType;
+  ByteArray storeData;
+  ByteArray firstNetState;
+  EntityId entityId;
+};
+
+// All entity deltas will be sent at the same time for the same connection
+// where they are master, any entities whose master is from that connection can
+// be assumed to have produced a blank delta.
+struct EntityUpdateSetPacket : PacketBase<PacketType::EntityUpdateSet> {
+  EntityUpdateSetPacket(ConnectionId forConnection = ServerConnectionId);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ConnectionId forConnection;
+  HashMap<EntityId, ByteArray> deltas;
+};
+
+struct EntityDestroyPacket : PacketBase<PacketType::EntityDestroy> {
+  EntityDestroyPacket();
+  EntityDestroyPacket(EntityId entityId, ByteArray finalNetState, bool death);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  EntityId entityId;
+  ByteArray finalNetState;
+  // If true, the entity removal is due to death rather simply for example
+  // going out of range of the entity monitoring window.
+  bool death;
+};
+
+struct EntityInteractPacket : PacketBase<PacketType::EntityInteract> {
+  EntityInteractPacket();
+  EntityInteractPacket(InteractRequest interactRequest, Uuid requestId);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  InteractRequest interactRequest;
+  Uuid requestId;
+};
+
+struct EntityInteractResultPacket : PacketBase<PacketType::EntityInteractResult> {
+  EntityInteractResultPacket();
+  EntityInteractResultPacket(InteractAction action, Uuid requestId, EntityId sourceEntityId);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  InteractAction action;
+  Uuid requestId;
+  EntityId sourceEntityId;
+};
+
+struct HitRequestPacket : PacketBase<PacketType::HitRequest> {
+  HitRequestPacket();
+  HitRequestPacket(RemoteHitRequest remoteHitRequest);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  RemoteHitRequest remoteHitRequest;
+};
+
+struct DamageRequestPacket : PacketBase<PacketType::DamageRequest> {
+  DamageRequestPacket();
+  DamageRequestPacket(RemoteDamageRequest remoteDamageRequest);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  RemoteDamageRequest remoteDamageRequest;
+};
+
+struct DamageNotificationPacket : PacketBase<PacketType::DamageNotification> {
+  DamageNotificationPacket();
+  DamageNotificationPacket(RemoteDamageNotification remoteDamageNotification);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  RemoteDamageNotification remoteDamageNotification;
+};
+
+struct EntityMessagePacket : PacketBase<PacketType::EntityMessage> {
+  EntityMessagePacket();
+  EntityMessagePacket(Variant<EntityId, String> entityId, String message, JsonArray args, Uuid uuid, ConnectionId fromConnection = ServerConnectionId);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Variant<EntityId, String> entityId;
+  String message;
+  JsonArray args;
+  Uuid uuid;
+  ConnectionId fromConnection;
+};
+
+struct EntityMessageResponsePacket : PacketBase<PacketType::EntityMessageResponse> {
+  EntityMessageResponsePacket();
+  EntityMessageResponsePacket(Either<String, Json> response, Uuid uuid);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Either<String, Json> response;
+  Uuid uuid;
+};
+
+struct UpdateWorldPropertiesPacket : PacketBase<PacketType::UpdateWorldProperties> {
+  UpdateWorldPropertiesPacket();
+  UpdateWorldPropertiesPacket(JsonObject const& updatedProperties);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  JsonObject updatedProperties;
+};
+
+struct StepUpdatePacket : PacketBase<PacketType::StepUpdate> {
+  StepUpdatePacket();
+  StepUpdatePacket(uint64_t remoteStep);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  uint64_t remoteStep;
+};
+
+struct SystemWorldStartPacket : PacketBase<PacketType::SystemWorldStart> {
+  SystemWorldStartPacket();
+  SystemWorldStartPacket(Vec3I location, List<ByteArray> objectStores, List<ByteArray> shipStores, pair<Uuid, SystemLocation> clientShip);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Vec3I location;
+  List<ByteArray> objectStores;
+  List<ByteArray> shipStores;
+  pair<Uuid, SystemLocation> clientShip;
+};
+
+struct SystemWorldUpdatePacket : PacketBase<PacketType::SystemWorldUpdate> {
+  SystemWorldUpdatePacket();
+  SystemWorldUpdatePacket(HashMap<Uuid, ByteArray> objectUpdates, HashMap<Uuid, ByteArray> shipUpdates);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  HashMap<Uuid, ByteArray> objectUpdates;
+  HashMap<Uuid, ByteArray> shipUpdates;
+};
+
+struct SystemObjectCreatePacket : PacketBase<PacketType::SystemObjectCreate> {
+  SystemObjectCreatePacket();
+  SystemObjectCreatePacket(ByteArray objectStore);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ByteArray objectStore;
+};
+
+struct SystemObjectDestroyPacket : PacketBase<PacketType::SystemObjectDestroy> {
+  SystemObjectDestroyPacket();
+  SystemObjectDestroyPacket(Uuid objectUuid);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Uuid objectUuid;
+};
+
+struct SystemShipCreatePacket : PacketBase<PacketType::SystemShipCreate> {
+  SystemShipCreatePacket();
+  SystemShipCreatePacket(ByteArray shipStore);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  ByteArray shipStore;
+};
+
+struct SystemShipDestroyPacket : PacketBase<PacketType::SystemShipDestroy> {
+  SystemShipDestroyPacket();
+  SystemShipDestroyPacket(Uuid shipUuid);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  Uuid shipUuid;
+};
+
+struct SystemObjectSpawnPacket : PacketBase<PacketType::SystemObjectSpawn> {
+  SystemObjectSpawnPacket();
+  SystemObjectSpawnPacket(String typeName, Uuid uuid, Maybe<Vec2F> position, JsonObject parameters);
+
+  void read(DataStream& ds) override;
+  void write(DataStream& ds) const override;
+
+  String typeName;
+  Uuid uuid;
+  Maybe<Vec2F> position;
+  JsonObject parameters;
+};
+}
+
+#endif