also tell connection handlers about ack'd packets

[blank.git] / src / net / net.cpp

diff --git a/src/net/net.cpp b/src/net/net.cpp
index 7f12e63ff3626b4d23f741d6d38cea9304ed7ad6..18761572bd13364cb10cddd6a2ac410c5d6b4b2d 100644 (file)
--- a/src/net/net.cpp
+++ b/src/net/net.cpp
@@ -11,6 +11,7 @@
 
 #include <cstring>
 #include <iostream>
+#include <glm/gtx/io.hpp>
 
 using namespace std;
 
@@ -21,6 +22,7 @@ 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;
 
 namespace {
 
@@ -101,6 +103,12 @@ uint16_t Client::SendLogin(const string &name) {
        return conn.Send(client_pack, client_sock);
 }
 
+uint16_t Client::SendPlayerUpdate(const Entity &player) {
+       auto pack = Packet::Make<Packet::PlayerUpdate>(client_pack);
+       pack.WritePlayer(player);
+       return conn.Send(client_pack, client_sock);
+}
+
 
 ClientConnection::ClientConnection(Server &server, const IPaddress &addr)
 : server(server)
@@ -162,6 +170,11 @@ void ClientConnection::On(const Packet::Part &) {
        conn.Close();
 }
 
+void ClientConnection::On(const Packet::PlayerUpdate &pack) {
+       if (!HasPlayer()) return;
+       pack.ReadPlayer(Player());
+}
+
 
 Connection::Connection(const IPaddress &addr)
 : handler(nullptr)
@@ -258,10 +271,23 @@ 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) {
+                       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<Packet::Ping>(udp_pack);
        return Send(udp_pack, sock);
@@ -291,6 +317,8 @@ const char *Packet::Type2String(uint8_t t) noexcept {
                        return "Join";
                case Part::TYPE:
                        return "Part";
+               case PlayerUpdate::TYPE:
+                       return "PlayerUpdate";
                default:
                        return "Unknown";
        }
@@ -383,6 +411,33 @@ void Packet::Join::ReadWorldName(string &name) const noexcept {
        ReadString(name, 68, 32);
 }
 
+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);
+}
+
+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;
+
+       Read(chunk_coords, 0);
+       Read(pos, 12);
+       Read(vel, 24);
+       Read(rot, 36);
+       Read(ang, 52);
+
+       player.Position(chunk_coords, pos);
+       player.Velocity(vel);
+       player.Orientation(rot);
+       player.AngularVelocity(ang);
+}
+
 
 void ConnectionHandler::Handle(const UDPpacket &udp_pack) {
        const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
@@ -399,6 +454,9 @@ void ConnectionHandler::Handle(const UDPpacket &udp_pack) {
                case Packet::Part::TYPE:
                        On(Packet::As<Packet::Part>(udp_pack));
                        break;
+               case Packet::PlayerUpdate::TYPE:
+                       On(Packet::As<Packet::PlayerUpdate>(udp_pack));
+                       break;
                default:
                        // drop unknown or unhandled packets
                        break;