116 lines
4.3 KiB
C++
116 lines
4.3 KiB
C++
#ifndef NET_CLASS
|
|
#define NET_CLASS
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <glm/glm.hpp>
|
|
#include <glm/gtc/quaternion.hpp>
|
|
|
|
// Multiplayer UDP link for a LAN pit. One player hosts (UDP port 27015), everyone else joins by IP.
|
|
// Clients send their own transform to the host every frame; the host relays everyone's
|
|
// transform to everyone else. The host is player id 0, joiners get ids 1, 2, 3, ...
|
|
// All Winsock code lives in Net.cpp so windows.h never leaks into the rest of the engine.
|
|
|
|
struct NetState {
|
|
glm::vec3 position = glm::vec3(0.0f);
|
|
glm::quat rotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
|
|
bool sliding = false;
|
|
};
|
|
|
|
// A state received for some other player.
|
|
struct NetUpdate {
|
|
uint8_t id = 0;
|
|
NetState state;
|
|
};
|
|
|
|
// A shockwave explosion. Every machine applies the launch to its own player, since remote
|
|
// players are only puppets here. Blasts are re-sent a few times (UDP) and de-duplicated on receive.
|
|
struct NetBlast {
|
|
uint8_t sender = 0; // filled in by the host; ignored on send
|
|
uint32_t id = 0; // filled in by SendBlast
|
|
glm::vec3 center = glm::vec3(0.0f);
|
|
float radius = 0.0f;
|
|
float power = 0.0f;
|
|
};
|
|
|
|
// Damage dealt to another player. Each machine owns its own player's health, so the shooter
|
|
// aims locally and sends this to the victim, who applies it. Re-sent a few times and de-duplicated.
|
|
struct NetHit {
|
|
uint8_t sender = 0; // filled in by the host
|
|
uint32_t id = 0; // filled in by SendHit
|
|
int damage = 0;
|
|
glm::vec3 knockback = glm::vec3(0.0f); // added to the victim's velocity
|
|
};
|
|
|
|
// A physics cube owned by the host. The host simulates every cube and streams their poses to the
|
|
// clients, which only draw them. The host also decides when a cube despawns.
|
|
struct NetCube {
|
|
uint32_t id = 0;
|
|
glm::vec3 position = glm::vec3(0.0f);
|
|
glm::quat rotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
|
|
};
|
|
|
|
// A client asking the host to spawn a cube. Re-sent a few times (UDP) and de-duplicated by the host.
|
|
struct NetCubeRequest {
|
|
uint8_t sender = 0; // filled in by the host
|
|
uint32_t id = 0;
|
|
glm::vec3 position = glm::vec3(0.0f);
|
|
};
|
|
|
|
class Lan {
|
|
public:
|
|
enum class Mode { Off, Host, Client };
|
|
|
|
// Total players in the pit, host included.
|
|
static constexpr int MaxPlayers = 8;
|
|
|
|
Lan();
|
|
~Lan();
|
|
|
|
// Opens the socket. For Client, hostIp is the host's IPv4 address. Returns false on failure.
|
|
bool Start(Mode mode, const std::string& hostIp);
|
|
void Stop();
|
|
|
|
Mode GetMode() const { return mode; }
|
|
bool IsActive() const { return active; }
|
|
|
|
// Call once per frame with our own state.
|
|
void Send(const NetState& state);
|
|
// Drains all waiting packets and appends the other players' newest states to 'out'.
|
|
// If 'blasts' is given, new (de-duplicated) shockwave blasts from other players are appended to it.
|
|
// 'hits' gets damage aimed at us (de-duplicated).
|
|
// 'spawns' (host only) gets cube spawn requests from clients; 'cubes' (client only) gets the
|
|
// host's cube poses.
|
|
void Receive(std::vector<NetUpdate>& out, std::vector<NetBlast>* blasts = nullptr,
|
|
std::vector<NetHit>* hits = nullptr, std::vector<NetCubeRequest>* spawns = nullptr,
|
|
std::vector<NetCube>* cubes = nullptr);
|
|
// Client: ask the host to spawn a cube at 'position'. Sent over the next few Send() calls.
|
|
void SendCubeSpawn(const glm::vec3& position);
|
|
// Host: stream cube poses to every client. Call once per frame; large sets go out in rotating
|
|
// slices, so a cube is refreshed every few frames.
|
|
void SendCubes(const std::vector<NetCube>& cubes);
|
|
// Damage another player. 'target' is the id from their NetUpdate (the host is 0).
|
|
void SendHit(uint8_t target, const NetHit& hit);
|
|
// Tell the other players about a blast we caused. Sent over the next few Send() calls.
|
|
void SendBlast(const NetBlast& blast);
|
|
|
|
// Host: at least one player has joined. Client: the host has been heard from in the last 2 s.
|
|
bool IsConnected() const;
|
|
// Host only: number of joined players, not counting the host.
|
|
int PeerCount() const;
|
|
|
|
// This machine's IPv4 addresses (for the host to read out to the joiners).
|
|
static std::string LocalAddresses();
|
|
|
|
private:
|
|
struct Impl;
|
|
Impl* impl;
|
|
Mode mode = Mode::Off;
|
|
bool active = false;
|
|
};
|
|
|
|
inline Lan* lan = nullptr;
|
|
|
|
#endif
|