X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;ds=sidebyside;f=src%2Fnet%2Fnet.cpp;h=18761572bd13364cb10cddd6a2ac410c5d6b4b2d;hb=b5a83cd3df5083ed0cccfe4876143e788b3836f9;hp=1be712b9fd51b0985da0b0924c29ae3c8cf0d248;hpb=1afc887a2040dfdedfa66913e94ff7a9634f648f;p=blank.git diff --git a/src/net/net.cpp b/src/net/net.cpp index 1be712b..1876157 100644 --- a/src/net/net.cpp +++ b/src/net/net.cpp @@ -1,8 +1,9 @@ #include "Client.hpp" +#include "ClientConnection.hpp" #include "Connection.hpp" +#include "ConnectionHandler.hpp" #include "io.hpp" #include "Packet.hpp" -#include "PacketHandler.hpp" #include "Server.hpp" #include "../app/init.hpp" @@ -10,12 +11,19 @@ #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; + namespace { UDPsocket client_bind(Uint16 port) { @@ -80,30 +88,101 @@ void Client::HandlePacket(const UDPpacket &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); } -void Client::SendLogin(const string &name) { +uint16_t Client::SendLogin(const string &name) { auto pack = Packet::Make(client_pack); pack.WritePlayerName(name); - conn.Send(client_pack, client_sock); + 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); +} + + +ClientConnection::ClientConnection(Server &server, const IPaddress &addr) +: server(server) +, conn(addr) +, player(nullptr) { + conn.SetHandler(this); +} + +ClientConnection::~ClientConnection() { + DetachPlayer(); +} + +void ClientConnection::Update(int dt) { + conn.Update(dt); + if (Disconnected()) { + cout << "disconnect from " << conn.Address() << endl; + } else if (conn.ShouldPing()) { + conn.SendPing(server.GetPacket(), server.GetSocket()); + } +} + +void ClientConnection::AttachPlayer(Entity &new_player) { + DetachPlayer(); + player = &new_player; + player->Ref(); +} + +void ClientConnection::DetachPlayer() { + if (!player) return; + player->Kill(); + player->UnRef(); + player = nullptr; +} + +void ClientConnection::On(const Packet::Login &pack) { + string name; + pack.ReadPlayerName(name); + + Entity *new_player = server.GetWorld().AddPlayer(name); + + 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()); + } 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; + pack.ReadPlayer(Player()); } Connection::Connection(const IPaddress &addr) : handler(nullptr) , addr(addr) -, send_timer(3000) +, send_timer(500) , recv_timer(10000) -, ctrl{ 0, 0xFFFF, 0xFFFF } +, ctrl_out{ 0, 0xFFFF, 0xFFFFFFFF } +, ctrl_in{ 0, 0xFFFF, 0xFFFFFFFF } , closed(false) { send_timer.Start(); recv_timer.Start(); @@ -122,7 +201,7 @@ void Connection::FlagRecv() noexcept { } bool Connection::ShouldPing() const noexcept { - return send_timer.HitOnce(); + return !closed && send_timer.HitOnce(); } bool Connection::TimedOut() const noexcept { @@ -132,15 +211,19 @@ 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 &udp_pack, UDPsocket sock) { +uint16_t Connection::Send(UDPpacket &udp_pack, UDPsocket sock) { Packet &pack = *reinterpret_cast(udp_pack.data); - pack.header.ctrl = ctrl; - ++ctrl.seq; - - cout << "sending " << pack.TypeString() << " to " << Address() << endl; + pack.header.ctrl = ctrl_out; + uint16_t seq = ctrl_out.seq++; udp_pack.address = addr; if (SDLNet_UDP_Send(sock, -1, &udp_pack) == 0) { @@ -148,52 +231,66 @@ void Connection::Send(UDPpacket &udp_pack, UDPsocket sock) { } FlagSend(); + return seq; } void Connection::Received(const UDPpacket &udp_pack) { Packet &pack = *reinterpret_cast(udp_pack.data); - cout << "received " << pack.TypeString() << " from " << Address() << endl; - - int diff = std::int16_t(pack.header.ctrl.seq) - std::int16_t(ctrl.ack); - + // ack to the remote + int16_t diff = int16_t(pack.header.ctrl.seq) - int16_t(ctrl_out.ack); if (diff > 0) { - // incoming more recent than last acked - - // TODO: packets considered lost are detected here - // this should have ones for all of them: - // ~hist & ((1 << dist) - 1) if dist is < 32 - if (diff >= 32) { - // missed more than the last 32 oO - ctrl.hist = 0; - } else { - ctrl.hist >>= diff; - ctrl.hist |= 1 << (32 - diff); - } - } else if (diff < 0) { - // incoming older than acked - if (diff > -32) { - // too late :/ + ctrl_out.hist = 0; } else { - ctrl.hist |= 1 << (32 + diff); + ctrl_out.hist <<= diff; + ctrl_out.hist |= 1 << (diff - 1); } - } else { - // incoming the same as last acked oO + } else if (diff < 0 && diff >= -32) { + ctrl_out.hist |= 1 << (-diff - 1); } + ctrl_out.ack = pack.header.ctrl.seq; + FlagRecv(); - ctrl.ack = pack.header.ctrl.seq; + if (!HasHandler()) { + return; + } + + Packet::TControl ctrl_new = pack.header.ctrl; + Handler().Handle(udp_pack); - if (HasHandler()) { - 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; } +} - FlagRecv(); +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; } -void Connection::SendPing(UDPpacket &udp_pack, UDPsocket sock) { +uint16_t Connection::SendPing(UDPpacket &udp_pack, UDPsocket sock) { Packet::Make(udp_pack); - Send(udp_pack, sock); + return Send(udp_pack, sock); } @@ -220,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"; } @@ -273,8 +372,7 @@ void Packet::Login::ReadPlayerName(string &name) const noexcept { } void Packet::Join::WritePlayer(const Entity &player) noexcept { - // TODO: generate entity IDs - Write(uint32_t(1), 0); + Write(player.ID(), 0); Write(player.ChunkCoords(), 4); Write(player.Position(), 16); Write(player.Velocity(), 28); @@ -282,15 +380,17 @@ void Packet::Join::WritePlayer(const Entity &player) noexcept { Write(player.AngularVelocity(), 56); } +void Packet::Join::ReadPlayerID(uint32_t &id) const noexcept { + Read(id, 0); +} + void Packet::Join::ReadPlayer(Entity &player) const noexcept { - uint32_t id = 0; glm::ivec3 chunk_coords(0); glm::vec3 pos; glm::vec3 vel; glm::quat rot; glm::vec3 ang; - Read(id, 0); Read(chunk_coords, 4); Read(pos, 16); Read(vel, 28); @@ -311,8 +411,35 @@ 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 PacketHandler::Handle(const UDPpacket &udp_pack) { +void ConnectionHandler::Handle(const UDPpacket &udp_pack) { const Packet &pack = *reinterpret_cast(udp_pack.data); switch (pack.Type()) { case Packet::Ping::TYPE: @@ -327,6 +454,9 @@ void PacketHandler::Handle(const UDPpacket &udp_pack) { case Packet::Part::TYPE: On(Packet::As(udp_pack)); break; + case Packet::PlayerUpdate::TYPE: + On(Packet::As(udp_pack)); + break; default: // drop unknown or unhandled packets break; @@ -377,85 +507,29 @@ void Server::HandlePacket(const UDPpacket &udp_pack) { return; } - Connection &client = GetClient(udp_pack.address); - client.Received(udp_pack); - - switch (pack.header.type) { - case Packet::Login::TYPE: - HandleLogin(client, udp_pack); - break; - case Packet::Part::TYPE: - HandlePart(client, udp_pack); - break; - default: - // just drop packets of unknown or unhandled 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->Closed()) { - 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) { - auto pack = Packet::As(udp_pack); - - string name; - pack.ReadPlayerName(name); - - Entity *player = world.AddPlayer(name); - - if (player) { - // success! - cout << "accepted login from player \"" << name << '"' << endl; - auto response = Packet::Make(serv_pack); - response.WritePlayer(*player); - response.WriteWorldName(world.Name()); - client.Send(serv_pack, serv_sock); - } else { - // aw no :( - cout << "rejected login from player \"" << name << '"' << endl; - Packet::Make(serv_pack); - client.Send(serv_pack, serv_sock); - client.Close(); - } -} - -void Server::HandlePart(Connection &client, const UDPpacket &udp_pack) { - client.Close(); -} - }