X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fnet%2Fnet.cpp;h=f59b80962530e5a4f4ca8b883b454247eb466a86;hb=ae5a7e7d8517fac406a88e9bf98fd3d5bb1728b9;hp=18761572bd13364cb10cddd6a2ac410c5d6b4b2d;hpb=b5a83cd3df5083ed0cccfe4876143e788b3836f9;p=blank.git diff --git a/src/net/net.cpp b/src/net/net.cpp index 1876157..f59b809 100644 --- a/src/net/net.cpp +++ b/src/net/net.cpp @@ -7,6 +7,10 @@ #include "Server.hpp" #include "../app/init.hpp" +#include "../model/CompositeModel.hpp" +#include "../world/ChunkIndex.hpp" +#include "../world/Entity.hpp" +#include "../world/EntityState.hpp" #include "../world/World.hpp" #include @@ -23,6 +27,12 @@ constexpr size_t Packet::Login::MAX_LEN; constexpr size_t Packet::Join::MAX_LEN; constexpr size_t Packet::Part::MAX_LEN; constexpr size_t Packet::PlayerUpdate::MAX_LEN; +constexpr size_t Packet::SpawnEntity::MAX_LEN; +constexpr size_t Packet::DespawnEntity::MAX_LEN; +constexpr size_t Packet::EntityUpdate::MAX_LEN; +constexpr size_t Packet::PlayerCorrection::MAX_LEN; +constexpr size_t Packet::ChunkBegin::MAX_LEN; +constexpr size_t Packet::ChunkData::MAX_LEN; namespace { @@ -109,11 +119,24 @@ uint16_t Client::SendPlayerUpdate(const Entity &player) { return conn.Send(client_pack, client_sock); } +uint16_t Client::SendPart() { + Packet::Make(client_pack); + return conn.Send(client_pack, client_sock); +} + ClientConnection::ClientConnection(Server &server, const IPaddress &addr) : server(server) , conn(addr) -, player(nullptr) { +, player(nullptr, nullptr) +, spawns() +, confirm_wait(0) +, player_update_state() +, player_update_pack(0) +, player_update_timer(1500) +, transmitter(*this) +, chunk_queue() +, old_base() { conn.SetHandler(this); } @@ -124,44 +147,277 @@ ClientConnection::~ClientConnection() { void ClientConnection::Update(int dt) { conn.Update(dt); if (Disconnected()) { - cout << "disconnect from " << conn.Address() << endl; - } else if (conn.ShouldPing()) { + return; + } + if (HasPlayer()) { + // sync entities + auto global_iter = server.GetWorld().Entities().begin(); + auto global_end = server.GetWorld().Entities().end(); + auto local_iter = spawns.begin(); + auto local_end = spawns.end(); + + while (global_iter != global_end && local_iter != local_end) { + if (global_iter->ID() == local_iter->entity->ID()) { + // they're the same + if (CanDespawn(*global_iter)) { + SendDespawn(*local_iter); + } else { + // update + SendUpdate(*local_iter); + } + ++global_iter; + ++local_iter; + } else if (global_iter->ID() < local_iter->entity->ID()) { + // global entity was inserted + if (CanSpawn(*global_iter)) { + auto spawned = spawns.emplace(local_iter, *global_iter); + SendSpawn(*spawned); + } + ++global_iter; + } else { + // global entity was removed + SendDespawn(*local_iter); + ++local_iter; + } + } + + // leftover spawns + while (global_iter != global_end) { + if (CanSpawn(*global_iter)) { + spawns.emplace_back(*global_iter); + SendSpawn(spawns.back()); + } + ++global_iter; + } + + // leftover despawns + while (local_iter != local_end) { + SendDespawn(*local_iter); + ++local_iter; + } + + CheckPlayerFix(); + CheckChunkQueue(); + } + if (conn.ShouldPing()) { conn.SendPing(server.GetPacket(), server.GetSocket()); } } -void ClientConnection::AttachPlayer(Entity &new_player) { +ClientConnection::SpawnStatus::SpawnStatus(Entity &e) +: entity(&e) +, spawn_pack(-1) +, despawn_pack(-1) { + entity->Ref(); +} + +ClientConnection::SpawnStatus::~SpawnStatus() { + entity->UnRef(); +} + +bool ClientConnection::CanSpawn(const Entity &e) const noexcept { + return + &e != player.entity && + !e.Dead() && + manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) < 7; +} + +bool ClientConnection::CanDespawn(const Entity &e) const noexcept { + return + e.Dead() || + manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) > 7; +} + +uint16_t ClientConnection::Send() { + return conn.Send(server.GetPacket(), server.GetSocket()); +} + +uint16_t ClientConnection::Send(size_t len) { + server.GetPacket().len = len; + return Send(); +} + +void ClientConnection::SendSpawn(SpawnStatus &status) { + // don't double spawn + if (status.spawn_pack != -1) return; + + auto pack = Prepare(); + pack.WriteEntity(*status.entity); + status.spawn_pack = Send(); + ++confirm_wait; +} + +void ClientConnection::SendDespawn(SpawnStatus &status) { + // don't double despawn + if (status.despawn_pack != -1) return; + + auto pack = Prepare(); + pack.WriteEntityID(status.entity->ID()); + status.despawn_pack = Send(); + ++confirm_wait; +} + +void ClientConnection::SendUpdate(SpawnStatus &status) { + // don't send updates while spawn not ack'd or despawn sent + if (status.spawn_pack != -1 || status.despawn_pack != -1) return; + + // TODO: pack entity updates + auto pack = Prepare(); + pack.WriteEntityCount(1); + pack.WriteEntity(*status.entity, 0); + Send(Packet::EntityUpdate::GetSize(1)); +} + +void ClientConnection::CheckPlayerFix() { + // player_update_state's position holds the client's most recent prediction + glm::vec3 diff = player_update_state.Diff(PlayerEntity().GetState()); + float dist_squared = dot(diff, diff); + + // if client's prediction is off by more than 1cm, send + // our (authoritative) state back so it can fix it + constexpr float fix_thresh = 0.0001f; + + if (dist_squared > fix_thresh) { + auto pack = Prepare(); + pack.WritePacketSeq(player_update_pack); + pack.WritePlayer(PlayerEntity()); + Send(); + } +} + +void ClientConnection::CheckChunkQueue() { + if (PlayerChunks().Base() != old_base) { + Chunk::Pos begin = PlayerChunks().CoordsBegin(); + Chunk::Pos end = PlayerChunks().CoordsEnd(); + for (Chunk::Pos pos = begin; pos.z < end.z; ++pos.z) { + for (pos.y = begin.y; pos.y < end.y; ++pos.y) { + for (pos.x = begin.x; pos.x < end.x; ++pos.x) { + if (manhattan_radius(pos - old_base) > PlayerChunks().Extent()) { + chunk_queue.push_back(pos); + } + } + } + } + old_base = PlayerChunks().Base(); + } + if (transmitter.Transmitting()) { + transmitter.Transmit(); + return; + } + if (transmitter.Idle()) { + int count = 0; + constexpr int max = 64; + while (count < max && !chunk_queue.empty()) { + Chunk::Pos pos = chunk_queue.front(); + chunk_queue.pop_front(); + if (PlayerChunks().InRange(pos)) { + Chunk *chunk = PlayerChunks().Get(pos); + if (chunk) { + transmitter.Send(*chunk); + return; + } else { + chunk_queue.push_back(pos); + } + ++count; + } + } + } +} + +void ClientConnection::AttachPlayer(const Player &new_player) { DetachPlayer(); - player = &new_player; - player->Ref(); + player = new_player; + player.entity->Ref(); + + old_base = player.chunks->Base(); + Chunk::Pos begin = player.chunks->CoordsBegin(); + Chunk::Pos end = player.chunks->CoordsEnd(); + for (Chunk::Pos pos = begin; pos.z < end.z; ++pos.z) { + for (pos.y = begin.y; pos.y < end.y; ++pos.y) { + for (pos.x = begin.x; pos.x < end.x; ++pos.x) { + chunk_queue.push_back(pos); + } + } + } + + cout << "player \"" << player.entity->Name() << "\" joined" << endl; } void ClientConnection::DetachPlayer() { - if (!player) return; - player->Kill(); - player->UnRef(); - player = nullptr; + if (!HasPlayer()) return; + cout << "player \"" << player.entity->Name() << "\" left" << endl; + player.entity->Kill(); + player.entity->UnRef(); + player.entity = nullptr; + player.chunks = nullptr; + transmitter.Abort(); + chunk_queue.clear(); +} + +void ClientConnection::OnPacketReceived(uint16_t seq) { + if (transmitter.Waiting()) { + transmitter.Ack(seq); + } + if (!confirm_wait) return; + for (auto iter = spawns.begin(), end = spawns.end(); iter != end; ++iter) { + if (seq == iter->spawn_pack) { + iter->spawn_pack = -1; + --confirm_wait; + return; + } + if (seq == iter->despawn_pack) { + spawns.erase(iter); + --confirm_wait; + return; + } + } +} + +void ClientConnection::OnPacketLost(uint16_t seq) { + if (transmitter.Waiting()) { + transmitter.Nack(seq); + } + if (!confirm_wait) return; + for (SpawnStatus &status : spawns) { + if (seq == status.spawn_pack) { + status.spawn_pack = -1; + --confirm_wait; + SendSpawn(status); + return; + } + if (seq == status.despawn_pack) { + status.despawn_pack = -1; + --confirm_wait; + SendDespawn(status); + return; + } + } } void ClientConnection::On(const Packet::Login &pack) { string name; pack.ReadPlayerName(name); - Entity *new_player = server.GetWorld().AddPlayer(name); + Player new_player = server.GetWorld().AddPlayer(name); - if (new_player) { + if (new_player.entity) { // success! - AttachPlayer(*new_player); + AttachPlayer(new_player); cout << "accepted login from player \"" << name << '"' << endl; - auto response = Packet::Make(server.GetPacket()); - response.WritePlayer(*new_player); + auto response = Prepare(); + response.WritePlayer(*new_player.entity); response.WriteWorldName(server.GetWorld().Name()); - conn.Send(server.GetPacket(), server.GetSocket()); + Send(); + // set up update tracking + player_update_state = new_player.entity->GetState(); + player_update_pack = pack.Seq(); + player_update_timer.Reset(); + player_update_timer.Start(); } else { // aw no :( cout << "rejected login from player \"" << name << '"' << endl; - Packet::Make(server.GetPacket()); - conn.Send(server.GetPacket(), server.GetSocket()); + Prepare(); + Send(); conn.Close(); } } @@ -172,7 +428,16 @@ void ClientConnection::On(const Packet::Part &) { void ClientConnection::On(const Packet::PlayerUpdate &pack) { if (!HasPlayer()) return; - pack.ReadPlayer(Player()); + int pack_diff = int16_t(pack.Seq()) - int16_t(player_update_pack); + bool overdue = player_update_timer.HitOnce(); + player_update_timer.Reset(); + if (pack_diff > 0 || overdue) { + player_update_pack = pack.Seq(); + pack.ReadPlayerState(player_update_state); + // accept velocity and orientation as "user input" + PlayerEntity().Velocity(player_update_state.velocity); + PlayerEntity().Orientation(player_update_state.orient); + } } @@ -272,7 +537,7 @@ void Connection::Received(const UDPpacket &udp_pack) { } } // check for newly ack'd packets - for (uint16_t s = ctrl_new.AckBegin(); s != ctrl_new.AckEnd(); ++s) { + for (uint16_t s = ctrl_new.AckBegin(); s != ctrl_new.AckEnd(); --s) { if (ctrl_new.Acks(s) && !ctrl_in.Acks(s)) { Handler().OnPacketReceived(s); } @@ -319,6 +584,18 @@ const char *Packet::Type2String(uint8_t t) noexcept { return "Part"; case PlayerUpdate::TYPE: return "PlayerUpdate"; + case SpawnEntity::TYPE: + return "SpawnEntity"; + case DespawnEntity::TYPE: + return "DespawnEntity"; + case EntityUpdate::TYPE: + return "EntityUpdate"; + case PlayerCorrection::TYPE: + return "PlayerCorrection"; + case ChunkBegin::TYPE: + return "ChunkBegin"; + case ChunkData::TYPE: + return "ChunkData"; default: return "Unknown"; } @@ -373,34 +650,15 @@ void Packet::Login::ReadPlayerName(string &name) const noexcept { void Packet::Join::WritePlayer(const Entity &player) noexcept { Write(player.ID(), 0); - Write(player.ChunkCoords(), 4); - Write(player.Position(), 16); - Write(player.Velocity(), 28); - Write(player.Orientation(), 40); - Write(player.AngularVelocity(), 56); + Write(player.GetState(), 4); } void Packet::Join::ReadPlayerID(uint32_t &id) const noexcept { Read(id, 0); } -void Packet::Join::ReadPlayer(Entity &player) const noexcept { - glm::ivec3 chunk_coords(0); - glm::vec3 pos; - glm::vec3 vel; - glm::quat rot; - glm::vec3 ang; - - Read(chunk_coords, 4); - Read(pos, 16); - Read(vel, 28); - Read(rot, 40); - Read(ang, 56); - - player.Position(chunk_coords, pos); - player.Velocity(vel); - player.Orientation(rot); - player.AngularVelocity(ang); +void Packet::Join::ReadPlayerState(EntityState &state) const noexcept { + Read(state, 4); } void Packet::Join::WriteWorldName(const string &name) noexcept { @@ -412,30 +670,167 @@ void Packet::Join::ReadWorldName(string &name) const noexcept { } void Packet::PlayerUpdate::WritePlayer(const Entity &player) noexcept { - Write(player.ChunkCoords(), 0); - Write(player.Position(), 12); - Write(player.Velocity(), 24); - Write(player.Orientation(), 36); - Write(player.AngularVelocity(), 52); + Write(player.GetState(), 0); +} + +void Packet::PlayerUpdate::ReadPlayerState(EntityState &state) const noexcept { + Read(state, 0); } -void Packet::PlayerUpdate::ReadPlayer(Entity &player) const noexcept { - glm::ivec3 chunk_coords(0); - glm::vec3 pos; - glm::vec3 vel; - glm::quat rot; - glm::vec3 ang; +void Packet::SpawnEntity::WriteEntity(const Entity &e) noexcept { + Write(e.ID(), 0); + if (e.GetModel()) { + Write(e.GetModel().GetModel().ID(), 4); + } else { + Write(uint32_t(0), 4); + } + Write(e.GetState(), 8); + Write(e.Bounds(), 72); + uint32_t flags = 0; + if (e.WorldCollidable()) { + flags |= 1; + } + Write(flags, 96); + WriteString(e.Name(), 100, 32); +} + +void Packet::SpawnEntity::ReadEntityID(uint32_t &id) const noexcept { + Read(id, 0); +} + +void Packet::SpawnEntity::ReadSkeletonID(uint32_t &id) const noexcept { + Read(id, 4); +} + +void Packet::SpawnEntity::ReadEntity(Entity &e) const noexcept { + EntityState state; + AABB bounds; + uint32_t flags = 0; + string name; + + Read(state, 8); + Read(bounds, 72); + Read(flags, 96); + ReadString(name, 100, 32); + + e.SetState(state); + e.Bounds(bounds); + e.WorldCollidable(flags & 1); + e.Name(name); +} + +void Packet::DespawnEntity::WriteEntityID(uint32_t id) noexcept { + Write(id, 0); +} + +void Packet::DespawnEntity::ReadEntityID(uint32_t &id) const noexcept { + Read(id, 0); +} - Read(chunk_coords, 0); - Read(pos, 12); - Read(vel, 24); - Read(rot, 36); - Read(ang, 52); +void Packet::EntityUpdate::WriteEntityCount(uint32_t count) noexcept { + Write(count, 0); +} + +void Packet::EntityUpdate::ReadEntityCount(uint32_t &count) const noexcept { + Read(count, 0); +} + +void Packet::EntityUpdate::WriteEntity(const Entity &entity, uint32_t num) noexcept { + uint32_t off = 4 + (num * 64); + + Write(entity.ID(), off); + Write(entity.GetState(), off + 4); +} - player.Position(chunk_coords, pos); - player.Velocity(vel); - player.Orientation(rot); - player.AngularVelocity(ang); +void Packet::EntityUpdate::ReadEntityID(uint32_t &id, uint32_t num) const noexcept { + Read(id, 4 + (num * 64)); +} + +void Packet::EntityUpdate::ReadEntityState(EntityState &state, uint32_t num) const noexcept { + uint32_t off = 4 + (num * 64); + Read(state, off + 4); +} + +void Packet::PlayerCorrection::WritePacketSeq(std::uint16_t s) noexcept { + Write(s, 0); +} + +void Packet::PlayerCorrection::ReadPacketSeq(std::uint16_t &s) const noexcept { + Read(s, 0); +} + +void Packet::PlayerCorrection::WritePlayer(const Entity &player) noexcept { + Write(player.GetState(), 2); +} + +void Packet::PlayerCorrection::ReadPlayerState(EntityState &state) const noexcept { + Read(state, 2); +} + +void Packet::ChunkBegin::WriteTransmissionId(uint32_t id) noexcept { + Write(id, 0); +} + +void Packet::ChunkBegin::ReadTransmissionId(uint32_t &id) const noexcept { + Read(id, 0); +} + +void Packet::ChunkBegin::WriteFlags(uint32_t f) noexcept { + Write(f, 4); +} + +void Packet::ChunkBegin::ReadFlags(uint32_t &f) const noexcept { + Read(f, 4); +} + +void Packet::ChunkBegin::WriteChunkCoords(const glm::ivec3 &pos) noexcept { + Write(pos, 8); +} + +void Packet::ChunkBegin::ReadChunkCoords(glm::ivec3 &pos) const noexcept { + Read(pos, 8); +} + +void Packet::ChunkBegin::WriteDataSize(uint32_t s) noexcept { + Write(s, 20); +} + +void Packet::ChunkBegin::ReadDataSize(uint32_t &s) const noexcept { + Read(s, 20); +} + +void Packet::ChunkData::WriteTransmissionId(uint32_t id) noexcept { + Write(id, 0); +} + +void Packet::ChunkData::ReadTransmissionId(uint32_t &id) const noexcept { + Read(id, 0); +} + +void Packet::ChunkData::WriteDataOffset(uint32_t o) noexcept { + Write(o, 4); +} + +void Packet::ChunkData::ReadDataOffset(uint32_t &o) const noexcept { + Read(o, 4); +} + +void Packet::ChunkData::WriteDataSize(uint32_t s) noexcept { + Write(s, 8); +} + +void Packet::ChunkData::ReadDataSize(uint32_t &s) const noexcept { + Read(s, 8); +} + +void Packet::ChunkData::WriteData(const uint8_t *d, size_t l) noexcept { + size_t len = min(length - 12, l); + memcpy(&data[12], d, len); +} + +void Packet::ChunkData::ReadData(uint8_t *d, size_t l) const noexcept { + size_t len = min(length - 12, l); + memcpy(d, &data[12], len); } @@ -457,6 +852,24 @@ void ConnectionHandler::Handle(const UDPpacket &udp_pack) { case Packet::PlayerUpdate::TYPE: On(Packet::As(udp_pack)); break; + case Packet::SpawnEntity::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::DespawnEntity::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::EntityUpdate::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::PlayerCorrection::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::ChunkBegin::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::ChunkData::TYPE: + On(Packet::As(udp_pack)); + break; default: // drop unknown or unhandled packets break;