Subversion Repositories Games.Descent

/*

 * This file is part of the DXX-Rebirth project <https://www.dxx-rebirth.com/>.

 * It is copyright by its individual contributors, as recorded in the

 * project's Git history.  See COPYING.txt at the top level for license

 * terms and a link to the Git history.

 */

/*

 *

 * Prototypes for UDP-protocol network management functions.

 *

 */

#pragma once

#include "multi.h"

#ifdef __cplusplus

#include "pack.h"

#include "ntstring.h"

#include "fwd-window.h"

#include <array>

// Exported functions

#ifdef dsx

namespace dsx {

window_event_result net_udp_setup_game(void);

}

#endif

void net_udp_manual_join_game();

void net_udp_list_join_game();

int net_udp_objnum_is_past(objnum_t objnum);

#ifdef dsx

namespace dsx {

void net_udp_do_frame(int force, int listen);

}

#endif

void net_udp_send_data(const uint8_t *ptr, unsigned len, int priority);

#ifdef dsx

namespace dsx {

void net_udp_leave_game();

int net_udp_endlevel(int *secret);

}

#endif

int net_udp_kmatrix_poll2( newmenu *menu,const d_event &event, const unused_newmenu_userdata_t *);

void net_udp_send_endlevel_packet();

void net_udp_dump_player(const _sockaddr &dump_addr, int why);

void net_udp_disconnect_player(int playernum);

window_event_result net_udp_level_sync();

void net_udp_send_mdata_direct(const ubyte *data, int data_len, int pnum, int priority);

void net_udp_send_netgame_update();

// Some defines

// Our default port - easy to remember: D = 4, X = 24, X = 24

constexpr uint16_t UDP_PORT_DEFAULT = 42424;

#define UDP_MANUAL_ADDR_DEFAULT "localhost"

#if DXX_USE_TRACKER

#ifndef TRACKER_ADDR_DEFAULT

/* Allow an alternate default at compile time */

#define TRACKER_ADDR_DEFAULT "tracker.dxx-rebirth.com"

#endif

constexpr uint16_t TRACKER_PORT_DEFAULT = 9999;

#endif

#define UDP_MAX_NETGAMES 900

namespace dcx {

constexpr std::integral_constant<unsigned, 12> UDP_NETGAMES_PPAGE{}; // Netgames on one page of Netlist

}

#define UDP_NETGAMES_PAGES 75 // Pages available on Netlist (UDP_MAX_NETGAMES/UDP_NETGAMES_PPAGE)

#define UDP_TIMEOUT (5*F1_0) // 5 seconds disconnect timeout

#define UDP_MDATA_STOR_QUEUE_SIZE 1024 // Store up to 1024 MDATA packets

#define UDP_MDATA_STOR_MIN_FREE_2JOIN 384 // have at least this many free packet slots before we let someone join the game

#define UDP_MDATA_PKT_NUM_MIN 1 // start from pkt_num 1 (0 is used to initialize the trace list)

#define UDP_MDATA_PKT_NUM_MAX (UDP_MDATA_STOR_QUEUE_SIZE*100) // the max value for pkt_num. roll over when we go any higher. this should be smaller than INT_MAX

// UDP-Packet identificators (ubyte) and their (max. sizes).

#define UPID_VERSION_DENY                         1 // Netgame join or info has been denied due to version difference.

#define UPID_VERSION_DENY_SIZE                    9

#define UPID_GAME_INFO_REQ                        2 // Requesting all info about a netgame.

#define UPID_GAME_INFO_REQ_SIZE                  13

#define UPID_GAME_INFO_LITE_REQ_SIZE             13

#define UPID_GAME_INFO                            3 // Packet containing all info about a netgame.

#define UPID_GAME_INFO_LITE_REQ                   4 // Requesting lite info about a netgame. Used for discovering games.

#define UPID_GAME_INFO_LITE                       5 // Packet containing lite netgame info.

#define UPID_GAME_INFO_SIZE_MAX                  (sizeof(netgame_info))

#define UPID_GAME_INFO_LITE_SIZE_MAX             (sizeof(UDP_netgame_info_lite))

#define UPID_DUMP                                 6 // Packet containing why player cannot join this game.

#define UPID_DUMP_SIZE                            2

#define UPID_ADDPLAYER                            7 // Packet from Host containing info about a new player.

#define UPID_REQUEST                              8 // New player says: "I want to be inside of you!" (haha, sorry I could not resist) / Packet containing request to join the game actually.

#define UPID_QUIT_JOINING                         9 // Packet from a player who suddenly quits joining.

#define UPID_SEQUENCE_SIZE                       (3 + (CALLSIGN_LEN+1))

#define UPID_SYNC                                10 // Packet from host containing full netgame info to sync players up.

#define UPID_OBJECT_DATA                         11 // Packet from host containing object buffer.

#define UPID_PING                                12 // Packet from host containing his GameTime and the Ping list. Client returns this time to host as UPID_PONG and adapts the ping list.

#define UPID_PING_SIZE                           37

#define UPID_PONG                                13 // Packet answer from client to UPID_PING. Contains the time the initial ping packet was sent.

#define UPID_PONG_SIZE                           10

#define UPID_ENDLEVEL_H                          14 // Packet from Host to all Clients containing connect-states and kills information about everyone in the game.

#define UPID_ENDLEVEL_C                          15 // Packet from Client to Host containing connect-state and kills information from this Client.

#define UPID_PDATA                               16 // Packet from player containing his movement data.

#define UPID_PDATA_SIZE                          49

#define UPID_MDATA_PNORM                         17 // Packet containing multi buffer from a player. Priority 0,1 - no ACK needed.

#define UPID_MDATA_PNEEDACK                      18 // Packet containing multi buffer from a player. Priority 2 - ACK needed. Also contains pkt_num

#define UPID_MDATA_ACK                           19 // ACK packet for UPID_MDATA_P1.

#define UPID_MAX_SIZE                          1024 // Max size for a packet

#define UPID_MDATA_BUF_SIZE                     454

#if DXX_USE_TRACKER

#define UPID_TRACKER_REGISTER                    21 // Register or update a game on the tracker.

#define UPID_TRACKER_REMOVE                      22 // Remove our game from the tracker.

#define UPID_TRACKER_REQGAMES                    23 // Request a list of all games stored on the tracker.

#define UPID_TRACKER_GAMEINFO                    24 // Packet containing info about a game

#define UPID_TRACKER_ACK                         25 // An ACK packet from the tracker

#define UPID_TRACKER_HOLEPUNCH                   26 // Hole punching process. Sent from client to tracker to request hole punching from game host and received by host from tracker to initiate hole punching to requesting client

#endif

// Structure keeping lite game infos (for netlist, etc.)

#if defined(DXX_BUILD_DESCENT_I) || defined(DXX_BUILD_DESCENT_II)

struct UDP_netgame_info_lite : public prohibit_void_ptr<UDP_netgame_info_lite>

{

        struct _sockaddr                game_addr;

        std::array<short, 3>                 program_iver;

        fix                             GameID;

        uint16_t                        TrackerGameID;

        ntstring<NETGAME_NAME_LEN> game_name;

        ntstring<MISSION_NAME_LEN> mission_title;

        ntstring<8> mission_name;

        int32_t                         levelnum;

        ubyte                           gamemode;

        ubyte                           RefusePlayers;

        ubyte                           difficulty;

        ubyte                           game_status;

        ubyte                           numconnected;

        ubyte                           max_numplayers;

        bit_game_flags game_flag;

};

#endif

struct UDP_sequence_packet : prohibit_void_ptr<UDP_sequence_packet>

{

        ubyte                           type;

        netplayer_info                  player;

};

// packet structure for multi-buffer

struct UDP_mdata_info : prohibit_void_ptr<UDP_mdata_info>

{

        ubyte                           type;

        ubyte                           Player_num;

        uint16_t                        mbuf_size;

        uint32_t                        pkt_num;

        std::array<uint8_t, UPID_MDATA_BUF_SIZE> mbuf;

};

// structure to store MDATA to maybe resend

struct UDP_mdata_store : prohibit_void_ptr<UDP_mdata_store>

{

        fix64                           pkt_initial_timestamp;                  // initial timestamp to see if packet is outdated

        std::array<fix64, MAX_PLAYERS>          pkt_timestamp;          // Packet timestamp

        std::array<uint32_t, MAX_PLAYERS>       pkt_num;                        // Packet number

        sbyte                           used;

        ubyte                           Player_num;                             // sender of this packet

        uint16_t                        data_size;

        std::array<uint8_t, MAX_PLAYERS>                player_ack;             // 0 if player has not ACK'd this packet, 1 if ACK'd or not connected

        std::array<uint8_t, UPID_MDATA_BUF_SIZE> data;          // extra data of a packet - contains all multibuf data we don't want to loose

};

// structure to keep track of MDATA packets we already got, which we expect from another player and the pkt_num for the next packet we want to send to another player

struct UDP_mdata_check : public prohibit_void_ptr<UDP_mdata_check>

{

        std::array<uint32_t, UDP_MDATA_STOR_QUEUE_SIZE>                 pkt_num;        // all those we got just recently, so we can ignore them if we get them again

        int                             cur_slot;                               // index we can use for a new pkt_num

        uint32_t                        pkt_num_torecv;                         // the next pkt_num we await for this player

        uint32_t                        pkt_num_tosend;                         // the next pkt_num we want to send to another player

};

#endif