space::MultiplayerSession Class Reference

Owns a host or client UDP session and exchanges replicated game state. More...

#include <examples/asteroids-net/multiplayer.hpp>

Public Member Functions
bool	active () const
	Returns whether a host or client session is active.
bool	connected () const
	Returns whether the local player has an established peer connection.
NetworkExchange	exchange (const NetworkState &local_state, float delta_time)
	Sends local state and receives remote updates.
void	host (const std::string &port, const std::string &player_name)
	Starts hosting a session.
bool	is_host () const
	Returns whether this session is the host.
void	join (const std::string &address, const std::string &port, const std::string &player_name, const std::string &join_code)
	Joins a hosted session.
const std::string &	join_code () const
	Returns the session join code.
std::uint8_t	local_player_id () const
	Returns the assigned local player slot.
	MultiplayerSession ()
	Initializes the networking subsystem.
	MultiplayerSession (const MultiplayerSession &)=delete
MultiplayerSession &	operator= (const MultiplayerSession &)=delete
const std::array< bool, NETWORK_PLAYER_COUNT > &	player_connected () const
	Returns connection flags indexed by player slot.
std::size_t	player_count () const
	Returns the number of connected players.
const std::array< std::string, NETWORK_PLAYER_COUNT > &	player_names () const
	Returns display names indexed by player slot.
const std::string &	port_mapping_status () const
	Returns the automatic router port-mapping status.
void	stop ()
	Stops the active host or client session.
	~MultiplayerSession ()
	Stops the session and releases networking resources.

Detailed Description

Owns a host or client UDP session and exchanges replicated game state.

Definition at line 92 of file multiplayer.hpp.

Constructor & Destructor Documentation

MultiplayerSession() [1/2]

space::MultiplayerSession::MultiplayerSession ( )

default

Initializes the networking subsystem.

~MultiplayerSession()

space::MultiplayerSession::~MultiplayerSession

(

)

Stops the session and releases networking resources.

Definition at line 13 of file multiplayer.cpp.

{ stop(); }

MultiplayerSession() [2/2]

space::MultiplayerSession::MultiplayerSession ( const MultiplayerSession & )

delete

Member Function Documentation

active()

bool space::MultiplayerSession::active ( ) const

nodiscard

Returns whether a host or client session is active.

Definition at line 197 of file multiplayer.cpp.

{ return session_active; }

connected()

bool space::MultiplayerSession::connected ( ) const

nodiscard

Returns whether the local player has an established peer connection.

Definition at line 198 of file multiplayer.cpp.

{ return player_count() > 1; }

exchange()

NetworkExchange space::MultiplayerSession::exchange	(	const NetworkState &	local_state,
		float	delta_time )

Sends local state and receives remote updates.

Parameters

local_state	Current local gameplay state.
delta_time	Frame duration in seconds.

Returns

Remote states received during this tick.

Definition at line 93 of file multiplayer.cpp.

                                                                                                  {
        NetworkExchange result{};
        if (!session_active) {
            return result;
        }
 
        if (assigned_player_id < NETWORK_PLAYER_COUNT) {
            peers[assigned_player_id].state = local_state;
        }
        if (host_role) {
            for (std::uint8_t player = 1; player < NETWORK_PLAYER_COUNT; ++player) {
                if (!peers[player].connected)
                    continue;
                peers[player].idle_seconds += delta_time;
                if (peers[player].idle_seconds > 5.0f) {
                    peers[player] = {};
                    connected_players[player] = false;
                    names[player].clear();
                }
            }
        } else if (assigned_player_id < NETWORK_PLAYER_COUNT && connected_players[0]) {
            peers[0].idle_seconds += delta_time;
            if (peers[0].idle_seconds > 5.0f) {
                for (std::uint8_t player = 0; player < NETWORK_PLAYER_COUNT; ++player) {
                    if (player != assigned_player_id) {
                        connected_players[player] = false;
                    }
                }
            }
        }
 
        while (1) {
            Packet packet{};
            mxnetwork::SocketAddress sender{};
            const ssize_t received = host_role ? socket.recvfrom(&packet, sizeof(packet), sender) : socket.recvfrom(&packet, sizeof(packet));
            if (received < 0) {
                break;
            }
            if (received != static_cast<ssize_t>(sizeof(packet)) || packet.magic != Packet{}.magic ||
                packet.version != Packet{}.version || packet.size != sizeof(Packet)) {
                continue;
            }
 
            if (host_role) {
                const std::string supplied_code(packet.join_code.data(), strnlen(packet.join_code.data(), packet.join_code.size()));
                if (supplied_code != session_join_code) {
                    continue;
                }
                const std::optional<std::uint8_t> player = find_or_assign_peer(sender);
                if (!player.has_value()) {
                    continue;
                }
                Peer &peer = peers[*player];
                if (packet.sequence <= peer.receive_sequence && peer.receive_sequence != 0) {
                    continue;
                }
                peer.receive_sequence = packet.sequence;
                peer.idle_seconds = 0.0f;
                peer.state = packet.state;
                peer.name = packet_name(packet.player_name);
                names[*player] = peer.name;
                connected_players[*player] = true;
                result.players.push_back({*player, packet.state});
            } else {
                peers[0].idle_seconds = 0.0f;
                for (std::uint8_t player = 0; player < NETWORK_PLAYER_COUNT; ++player) {
                    connected_players[player] = (packet.connected_mask & (1U << player)) != 0U;
                }
                if (packet.assigned_player_id < NETWORK_PLAYER_COUNT) {
                    assigned_player_id = packet.assigned_player_id;
                    names[assigned_player_id] = local_player_name;
                    connected_players[assigned_player_id] = true;
                }
                if (packet.player_id < NETWORK_PLAYER_COUNT) {
                    names[packet.player_id] = packet_name(packet.player_name);
                    connected_players[packet.player_id] = true;
                    result.players.push_back({packet.player_id, packet.state});
                }
            }
        }
 
        send_accumulator += delta_time;
        if (send_accumulator >= (1.0f / 30.0f)) {
            send_accumulator = 0.0f;
            if (host_role) {
                for (std::uint8_t destination = 1; destination < NETWORK_PLAYER_COUNT; ++destination) {
                    if (!peers[destination].connected) {
                        continue;
                    }
                    for (std::uint8_t source = 0; source < NETWORK_PLAYER_COUNT; ++source) {
                        if (peers[source].connected) {
                            send_host_relay(source, destination);
                        }
                    }
                }
            } else {
                send_client_state(local_state);
            }
        } else if (!host_role && assigned_player_id == 0xFFU) {
            send_client_state(local_state);
        }
        return result;
    }

host()

void space::MultiplayerSession::host	(	const std::string &	port,
		const std::string &	player_name )

Starts hosting a session.

Parameters

port	Local UDP port.
player_name	Host display name.

Definition at line 37 of file multiplayer.cpp.

                                                                                     {
        stop();
        socket = mxnetwork::Socket(mxnetwork::SocketType::TYPE_INET_DGRAM);
        socket.bind(port);
        if (!socket.setblocking(false)) {
            stop();
            throw mxnetwork::Exception("Could not make the host UDP socket nonblocking.");
        }
        port_mapping = std::make_unique<PortMapping>();
        port_mapping->open(port);
        session_active = true;
        host_role = true;
        assigned_player_id = 0;
        local_player_name = player_name;
        names[0] = player_name;
        connected_players[0] = true;
        peers[0].connected = true;
        peers[0].name = player_name;
        session_join_code = random_join_code();
    }

is_host()

bool space::MultiplayerSession::is_host ( ) const

nodiscard

Returns whether this session is the host.

Definition at line 199 of file multiplayer.cpp.

{ return host_role; }

join()

void space::MultiplayerSession::join	(	const std::string &	address,
		const std::string &	port,
		const std::string &	player_name,
		const std::string &	join_code )

Joins a hosted session.

Parameters

address	Host address.
port	Host UDP port.
player_name	Local display name.
join_code	Host-provided session code.

Definition at line 58 of file multiplayer.cpp.

                                                                                                                                           {
        stop();
        socket = mxnetwork::Socket(mxnetwork::SocketType::TYPE_INET_DGRAM);
        if (!socket.connect(address, port)) {
            stop();
            throw mxnetwork::Exception("Could not connect the UDP socket to the host.");
        }
        if (!socket.setblocking(false)) {
            stop();
            throw mxnetwork::Exception("Could not make the client UDP socket nonblocking.");
        }
        session_active = true;
        host_role = false;
        local_player_name = player_name;
        session_join_code = join_code;
    }

join_code()

const std::string & space::MultiplayerSession::join_code ( ) const

nodiscard

Returns the session join code.

Definition at line 208 of file multiplayer.cpp.

{ return session_join_code; }

local_player_id()

std::uint8_t space::MultiplayerSession::local_player_id ( ) const

nodiscard

Returns the assigned local player slot.

Definition at line 200 of file multiplayer.cpp.

{ return assigned_player_id; }

operator=()

MultiplayerSession & space::MultiplayerSession::operator= ( const MultiplayerSession & )

delete

player_connected()

const std::array< bool, NETWORK_PLAYER_COUNT > & space::MultiplayerSession::player_connected ( ) const

nodiscard

Returns connection flags indexed by player slot.

Definition at line 207 of file multiplayer.cpp.

{ return connected_players; }

player_count()

std::size_t space::MultiplayerSession::player_count ( ) const

nodiscard

Returns the number of connected players.

Definition at line 202 of file multiplayer.cpp.

                                                     {
        return static_cast<std::size_t>(std::count(connected_players.begin(), connected_players.end(), true));
    }

player_names()

const std::array< std::string, NETWORK_PLAYER_COUNT > & space::MultiplayerSession::player_names ( ) const

nodiscard

Returns display names indexed by player slot.

Definition at line 206 of file multiplayer.cpp.

{ return names; }

port_mapping_status()

const std::string & space::MultiplayerSession::port_mapping_status ( ) const

nodiscard

Returns the automatic router port-mapping status.

Definition at line 210 of file multiplayer.cpp.

                                                                   {
        static const std::string NO_MAPPING = "Automatic router mapping unavailable; forward the UDP port manually.";
        return port_mapping ? port_mapping->status() : NO_MAPPING;
    }

stop()

void space::MultiplayerSession::stop

(

)

Stops the active host or client session.

Definition at line 75 of file multiplayer.cpp.

                                  {
        port_mapping.reset();
        if (socket.valid()) {
            socket.close();
        }
        socket = mxnetwork::Socket{};
        session_active = false;
        host_role = false;
        send_accumulator = 0.0f;
        send_sequence = 0;
        assigned_player_id = 0xFFU;
        local_player_name.clear();
        session_join_code.clear();
        peers = {};
        names = {};
        connected_players = {};
    }

---

The documentation for this class was generated from the following files:

• examples/asteroids-net/multiplayer.hpp
• examples/asteroids-net/multiplayer.cpp