X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fnet%2Fnet.cpp;h=3f4bf7453eab78a0ac79b7f045026ec10114a8f0;hb=8507332e2d0c54aec4045fb6f0021bdc3bd57750;hp=20b6f5c22660d8c27b474d0d8e652369dd650bcc;hpb=104592aabdc70b21065c35fe4d092fc6cdaa1f49;p=blank.git diff --git a/src/net/net.cpp b/src/net/net.cpp index 20b6f5c..3f4bf74 100644 --- a/src/net/net.cpp +++ b/src/net/net.cpp @@ -1,20 +1,36 @@ #include "Client.hpp" +#include "ClientConnection.hpp" #include "Connection.hpp" +#include "ConnectionHandler.hpp" #include "io.hpp" #include "Packet.hpp" #include "Server.hpp" #include "../app/init.hpp" +#include "../model/CompositeModel.hpp" +#include "../world/Entity.hpp" +#include "../world/EntityState.hpp" #include "../world/World.hpp" #include #include +#include using namespace std; namespace blank { +constexpr size_t Packet::Ping::MAX_LEN; +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; + namespace { UDPsocket client_bind(Uint16 port) { @@ -35,9 +51,8 @@ IPaddress client_resolve(const char *host, Uint16 port) { } -Client::Client(const Config &conf, World &world) -: world(world) -, conn(client_resolve(conf.host.c_str(), conf.port)) +Client::Client(const Config &conf) +: conn(client_resolve(conf.host.c_str(), conf.port)) , client_sock(client_bind(0)) , client_pack{ -1, nullptr, 0 } { client_pack.data = new Uint8[sizeof(Packet)]; @@ -75,34 +90,277 @@ void Client::HandlePacket(const UDPpacket &udp_pack) { return; } - conn.FlagRecv(); - cout << "I got something!" << endl; + conn.Received(udp_pack); } void Client::Update(int dt) { conn.Update(dt); - if (conn.TimedOut()) { - cout << "connection timed out :(" << endl; - } else if (conn.ShouldPing()) { + if (conn.ShouldPing()) { SendPing(); } } -void Client::SendPing() { - conn.SendPing(client_pack, client_sock); +uint16_t Client::SendPing() { + return conn.SendPing(client_pack, client_sock); +} + +uint16_t Client::SendLogin(const string &name) { + auto pack = Packet::Make(client_pack); + pack.WritePlayerName(name); + return conn.Send(client_pack, client_sock); +} + +uint16_t Client::SendPlayerUpdate(const Entity &player) { + auto pack = Packet::Make(client_pack); + pack.WritePlayer(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) +, spawns() +, confirm_wait(0) +, player_update_pack(0) +, player_update_timer(1500) { + conn.SetHandler(this); +} + +ClientConnection::~ClientConnection() { + DetachPlayer(); +} + +void ClientConnection::Update(int dt) { + conn.Update(dt); + if (Disconnected()) { + 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(); + } + if (conn.ShouldPing()) { + conn.SendPing(server.GetPacket(), server.GetSocket()); + } +} + +ClientConnection::SpawnStatus::SpawnStatus(Entity &e) +: entity(&e) +, spawn_pack(-1) +, despawn_pack(-1) { + entity->Ref(); } -void Client::SendLogin(const string &name) { - Packet &pack = *reinterpret_cast(client_pack.data); - client_pack.len = pack.Login(name); - conn.Send(client_pack, client_sock); +ClientConnection::SpawnStatus::~SpawnStatus() { + entity->UnRef(); +} + +bool ClientConnection::CanSpawn(const Entity &e) const noexcept { + return + &e != player && + !e.Dead() && + manhattan_radius(e.ChunkCoords() - Player().ChunkCoords()) < 7; +} + +bool ClientConnection::CanDespawn(const Entity &e) const noexcept { + return + e.Dead() || + manhattan_radius(e.ChunkCoords() - Player().ChunkCoords()) > 7; +} + +void ClientConnection::SendSpawn(SpawnStatus &status) { + // don't double spawn + if (status.spawn_pack != -1) return; + + auto pack = Packet::Make(server.GetPacket()); + pack.WriteEntity(*status.entity); + status.spawn_pack = conn.Send(server.GetPacket(), server.GetSocket()); + ++confirm_wait; +} + +void ClientConnection::SendDespawn(SpawnStatus &status) { + // don't double despawn + if (status.despawn_pack != -1) return; + + auto pack = Packet::Make(server.GetPacket()); + pack.WriteEntityID(status.entity->ID()); + status.despawn_pack = conn.Send(server.GetPacket(), server.GetSocket()); + ++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 = Packet::Make(server.GetPacket()); + pack.WriteEntityCount(1); + pack.WriteEntity(*status.entity, 0); + server.GetPacket().len = Packet::EntityUpdate::GetSize(1); + conn.Send(server.GetPacket(), server.GetSocket()); +} + +void ClientConnection::CheckPlayerFix() { + // check always succeeds for now ;) + auto pack = Packet::Make(server.GetPacket()); + pack.WritePacketSeq(player_update_pack); + pack.WritePlayer(Player()); + conn.Send(server.GetPacket(), server.GetSocket()); +} + +void ClientConnection::AttachPlayer(Entity &new_player) { + DetachPlayer(); + player = &new_player; + player->Ref(); + cout << "player \"" << player->Name() << "\" joined" << endl; +} + +void ClientConnection::DetachPlayer() { + if (!player) return; + player->Kill(); + player->UnRef(); + cout << "player \"" << player->Name() << "\" left" << endl; + player = nullptr; +} + +void ClientConnection::OnPacketReceived(uint16_t 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 (!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).entity; + + if (new_player) { + // success! + AttachPlayer(*new_player); + cout << "accepted login from player \"" << name << '"' << endl; + auto response = Packet::Make(server.GetPacket()); + response.WritePlayer(*new_player); + response.WriteWorldName(server.GetWorld().Name()); + conn.Send(server.GetPacket(), server.GetSocket()); + // set up update tracking + 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()); + conn.Close(); + } +} + +void ClientConnection::On(const Packet::Part &) { + conn.Close(); +} + +void ClientConnection::On(const Packet::PlayerUpdate &pack) { + if (!HasPlayer()) return; + 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(); + // TODO: do client input validation here + pack.ReadPlayerState(Player().GetState()); + } } Connection::Connection(const IPaddress &addr) -: addr(addr) -, send_timer(5000) -, recv_timer(10000) { +: handler(nullptr) +, addr(addr) +, send_timer(500) +, recv_timer(10000) +, ctrl_out{ 0, 0xFFFF, 0xFFFFFFFF } +, ctrl_in{ 0, 0xFFFF, 0xFFFFFFFF } +, closed(false) { send_timer.Start(); recv_timer.Start(); } @@ -120,7 +378,7 @@ void Connection::FlagRecv() noexcept { } bool Connection::ShouldPing() const noexcept { - return send_timer.HitOnce(); + return !closed && send_timer.HitOnce(); } bool Connection::TimedOut() const noexcept { @@ -130,21 +388,86 @@ bool Connection::TimedOut() const noexcept { void Connection::Update(int dt) { send_timer.Update(dt); recv_timer.Update(dt); + if (TimedOut()) { + Close(); + if (HasHandler()) { + Handler().OnTimeout(); + } + } } -void Connection::Send(UDPpacket &pack, UDPsocket sock) { - pack.address = addr; - if (SDLNet_UDP_Send(sock, -1, &pack) == 0) { +uint16_t Connection::Send(UDPpacket &udp_pack, UDPsocket sock) { + Packet &pack = *reinterpret_cast(udp_pack.data); + pack.header.ctrl = ctrl_out; + uint16_t seq = ctrl_out.seq++; + + udp_pack.address = addr; + if (SDLNet_UDP_Send(sock, -1, &udp_pack) == 0) { throw NetError("SDLNet_UDP_Send"); } + FlagSend(); + return seq; } -void Connection::SendPing(UDPpacket &udp_pack, UDPsocket sock) { +void Connection::Received(const UDPpacket &udp_pack) { Packet &pack = *reinterpret_cast(udp_pack.data); - udp_pack.len = pack.Ping(); - Send(udp_pack, sock); + + // ack to the remote + int16_t diff = int16_t(pack.header.ctrl.seq) - int16_t(ctrl_out.ack); + if (diff > 0) { + if (diff >= 32) { + ctrl_out.hist = 0; + } else { + ctrl_out.hist <<= diff; + ctrl_out.hist |= 1 << (diff - 1); + } + } else if (diff < 0 && diff >= -32) { + ctrl_out.hist |= 1 << (-diff - 1); + } + ctrl_out.ack = pack.header.ctrl.seq; + FlagRecv(); + + if (!HasHandler()) { + return; + } + + Packet::TControl ctrl_new = pack.header.ctrl; + Handler().Handle(udp_pack); + + if (diff > 0) { + // if the packet holds more recent information + // check if remote failed to ack one of our packets + diff = int16_t(ctrl_new.ack) - int16_t(ctrl_in.ack); + // should always be true, but you never know… + if (diff > 0) { + for (int i = 0; i < diff; ++i) { + if (i > 32 || (i < 32 && (ctrl_in.hist & (1 << (31 - i))) == 0)) { + Handler().OnPacketLost(ctrl_in.ack - 32 + i); + } + } + } + // check for newly ack'd packets + for (uint16_t s = ctrl_new.AckBegin(); s != ctrl_new.AckEnd(); ++s) { + if (ctrl_new.Acks(s) && !ctrl_in.Acks(s)) { + Handler().OnPacketReceived(s); + } + } + ctrl_in = ctrl_new; + } +} + +bool Packet::TControl::Acks(uint16_t s) const noexcept { + int16_t diff = int16_t(ack) - int16_t(s); + if (diff == 0) return true; + if (diff < 0 || diff > 32) return false; + return (hist & (1 << (diff - 1))) != 0; +} + +uint16_t Connection::SendPing(UDPpacket &udp_pack, UDPsocket sock) { + Packet::Make(udp_pack); + return Send(udp_pack, sock); } @@ -161,28 +484,232 @@ ostream &operator <<(ostream &out, const IPaddress &addr) { } -void Packet::Tag() noexcept { - header.tag = TAG; +const char *Packet::Type2String(uint8_t t) noexcept { + switch (t) { + case Ping::TYPE: + return "Ping"; + case Login::TYPE: + return "Login"; + case Join::TYPE: + return "Join"; + case Part::TYPE: + 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"; + default: + return "Unknown"; + } +} + +template +void Packet::Payload::Write(const T &src, size_t off) noexcept { + if ((length - off) < sizeof(T)) { + // dismiss out of bounds write + return; + } + *reinterpret_cast(&data[off]) = src; +} + +template +void Packet::Payload::Read(T &dst, size_t off) const noexcept { + if ((length - off) < sizeof(T)) { + // dismiss out of bounds read + return; + } + dst = *reinterpret_cast(&data[off]); +} + +void Packet::Payload::WriteString(const string &src, size_t off, size_t maxlen) noexcept { + uint8_t *dst = &data[off]; + size_t len = min(maxlen, length - off); + if (src.size() < len) { + memset(dst, '\0', len); + memcpy(dst, src.c_str(), src.size()); + } else { + memcpy(dst, src.c_str(), len); + } +} + +void Packet::Payload::ReadString(string &dst, size_t off, size_t maxlen) const noexcept { + size_t len = min(maxlen, length - off); + dst.clear(); + dst.reserve(len); + for (size_t i = 0; i < len && data[off + i] != '\0'; ++i) { + dst.push_back(data[off + i]); + } +} + + +void Packet::Login::WritePlayerName(const string &name) noexcept { + WriteString(name, 0, 32); +} + +void Packet::Login::ReadPlayerName(string &name) const noexcept { + ReadString(name, 0, 32); +} + +void Packet::Join::WritePlayer(const Entity &player) noexcept { + Write(player.ID(), 0); + Write(player.GetState(), 4); +} + +void Packet::Join::ReadPlayerID(uint32_t &id) const noexcept { + Read(id, 0); +} + +void Packet::Join::ReadPlayerState(EntityState &state) const noexcept { + Read(state, 4); +} + +void Packet::Join::WriteWorldName(const string &name) noexcept { + WriteString(name, 68, 32); } -size_t Packet::Ping() noexcept { - Tag(); - header.type = PING; - return sizeof(Header); +void Packet::Join::ReadWorldName(string &name) const noexcept { + ReadString(name, 68, 32); } -size_t Packet::Login(const string &name) noexcept { - constexpr size_t maxname = 32; +void Packet::PlayerUpdate::WritePlayer(const Entity &player) noexcept { + Write(player.GetState(), 0); +} + +void Packet::PlayerUpdate::ReadPlayerState(EntityState &state) const noexcept { + Read(state, 0); +} - Tag(); - header.type = LOGIN; - if (name.size() < maxname) { - memset(payload, '\0', maxname); - memcpy(payload, name.c_str(), name.size()); +void Packet::SpawnEntity::WriteEntity(const Entity &e) noexcept { + Write(e.ID(), 0); + if (e.GetModel()) { + Write(e.GetModel().GetModel().ID(), 4); } else { - memcpy(payload, name.c_str(), maxname); + 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); +} + +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); +} + +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 ConnectionHandler::Handle(const UDPpacket &udp_pack) { + const Packet &pack = *reinterpret_cast(udp_pack.data); + switch (pack.Type()) { + case Packet::Ping::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::Login::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::Join::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::Part::TYPE: + On(Packet::As(udp_pack)); + break; + 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; + default: + // drop unknown or unhandled packets + break; } - return sizeof(Header) + maxname; } @@ -229,77 +756,29 @@ void Server::HandlePacket(const UDPpacket &udp_pack) { return; } - Connection &client = GetClient(udp_pack.address); - client.FlagRecv(); - - switch (pack.header.type) { - case Packet::PING: - // already done all that's supposed to do - break; - case Packet::LOGIN: - HandleLogin(client, udp_pack); - break; - default: - // just drop packets of unknown type - break; - } + ClientConnection &client = GetClient(udp_pack.address); + client.GetConnection().Received(udp_pack); } -Connection &Server::GetClient(const IPaddress &addr) { - for (Connection &client : clients) { +ClientConnection &Server::GetClient(const IPaddress &addr) { + for (ClientConnection &client : clients) { if (client.Matches(addr)) { return client; } } - clients.emplace_back(addr); - OnConnect(clients.back()); + clients.emplace_back(*this, addr); return clients.back(); } -void Server::OnConnect(Connection &client) { - cout << "new connection from " << client.Address() << endl; - // tell it we're alive - client.SendPing(serv_pack, serv_sock); -} - void Server::Update(int dt) { - for (list::iterator client(clients.begin()), end(clients.end()); client != end;) { + for (list::iterator client(clients.begin()), end(clients.end()); client != end;) { client->Update(dt); - if (client->TimedOut()) { - OnDisconnect(*client); + if (client->Disconnected()) { client = clients.erase(client); } else { - if (client->ShouldPing()) { - client->SendPing(serv_pack, serv_sock); - } ++client; } } } -void Server::OnDisconnect(Connection &client) { - cout << "connection timeout from " << client.Address() << endl; -} - - -void Server::HandleLogin(Connection &client, const UDPpacket &udp_pack) { - const Packet &pack = *reinterpret_cast(udp_pack.data); - size_t maxlen = min(udp_pack.len - int(sizeof(Packet::Header)), 32); - string name; - name.reserve(maxlen); - for (size_t i = 0; i < maxlen && pack.payload[i] != '\0'; ++i) { - name.push_back(pack.payload[i]); - } - cout << "got login request from player \"" << name << '"' << endl; - - Entity *player = world.AddPlayer(name); - if (player) { - // success! - cout << "\taccepted" << endl; - } else { - // aw no :( - cout << "\trejected" << endl; - } -} - }