path: root/src/libparsec/include/net_defs.h

/*
 * PARSEC HEADER: net_defs.h
 */

#ifndef _NET_DEFS_H_
#define _NET_DEFS_H_


// ----------------------------------------------------------------------------
// NETWORKING SUBSYSTEM (NET) related definitions                             -
// ----------------------------------------------------------------------------


// possible values and masks of global NetworkGame ----------------------------
//
#define NETWORK_GAME_OFF		0x00
#define NETWORK_GAME_ON 		0x01
#define NETWORK_GAME_SIMULATED	0x02


// game management constants (special values of global CurGameTime) -----------
//
#define GAME_NOTSTARTEDYET		-1
#define GAME_FINISHED_TIME		-2
#define GAME_FINISHED_KILLS		-3
#define GAME_TERMINATED			-4
#define GAME_PEERTOPEER			-5

#define GAME_RUNNING()			( CurGameTime >= 0 )
#define GAME_OVER()				( ( CurGameTime == GAME_FINISHED_TIME ) || ( CurGameTime == GAME_FINISHED_KILLS ) )
#define GAME_NO_SERVER()		( CurGameTime == GAME_PEERTOPEER )


// identification of killer ---------------------------------------------------
//
#define KILLERID_UNKNOWN		0		// playerid of killer not known
#define KILLERID_BIAS			1		// playerid bias (additive)

// number of allocated network slots (absolute maximum number of players) -----
//
#define MAX_NET_ALLOC_SLOTS		16

// special player ids ---------------------------------------------------------
//
#define PLAYERID_SERVER			128		// packet destination is the server
#define PLAYERID_ANONYMOUS		-2		// packet sender is not connected
#define PLAYERID_MASTERSERVER	-3		// packet sender is masterserver
#define PLAYERID_INVALID		-4		// invalid sender

// maximum number of simultaneous network players in game-server mode ---------
//
#define MAX_NET_GMSV_PLAYERS	MAX_NET_ALLOC_SLOTS

// maximum number of simultaneous network players in peer-to-peer mode --------
//
#define MAX_NET_UDP_PEER_PLAYERS	8
#define MAX_NET_IPX_PEER_PLAYERS	4


// current maximum number of network players, depending on active protocol ----
//
#define MAX_NET_PROTO_PLAYERS	CurMaxPlayers	// declared in NET_GLOB.H


// node address compare results -----------------------------------------------
//
#define NODECMP_LESSTHAN		-1
#define NODECMP_EQUAL			0
#define NODECMP_GREATERTHAN		1


// message id for connectionless datagrams ------------------------------------
//
#define MSGID_DATAGRAM			0xFFFFFFFF

// size of packet signature ---------------------------------------------------
//
#define PACKET_SIGNATURE_SIZE	8


// maximum packet payload for ipx ---------------------------------------------
//
#define NET_IPX_DATA_LENGTH		546


// maximum packet payload for udp ---------------------------------------------
//
#define NET_UDP_DATA_LENGTH		1400


// current maximum packet payload ---------------------------------------------
//
#ifdef PARSEC_CLIENT
	#define NET_MAX_DATA_LENGTH		CurMaxDataLength
#else // !PARSEC_CLIENT
	#define NET_MAX_DATA_LENGTH		NET_UDP_DATA_LENGTH
#endif // !PARSEC_CLIENT


// max. length of internal packets --------------------------------------------
//
#define NET_MAX_NETPACKET_INTERNAL_LEN		2 * NET_UDP_DATA_LENGTH


// size of statically allocated packets ---------------------------------------
//
#define NET_ALLOC_DATA_LENGTH	NET_UDP_DATA_LENGTH


// size of remote packet stored into file (by recording it) -------------------
//
#define RECORD_PACKET_SIZE		NET_ALLOC_DATA_LENGTH


// maximum number of pending slot requests ------------------------------------
//
#define MAX_SLOT_REQUESTS		8


// maximum number of bytes in a remote address --------------------------------
// (regardless of protocol; accommodates IPv6)
#define MAX_NODE_ADDRESS_BYTES	16


// maximum number of specified masterservers ----------------------------------
//
#define MAX_MASTERSERVERS		3


// maximum number of servers (for serverlist and starmap) ---------------------
//
#define MAX_SERVERS				256


// maximum # of links from one server -----------------------------------------
//
#define MAX_NUM_LINKS			16


// maximum # of map objects ---------------------------------------------------
//
#define MAX_MAP_OBJECTS			128

// max. length of map object names --------------------------------------------
//
#define MAX_MAP_OBJ_NAME 		31


// various size constants -----------------------------------------------------
//
#include "net_limits.h"


// encapsulate node address in portable manner --------------------------------
//
struct node_t {
	byte		address[ MAX_NODE_ADDRESS_BYTES ];
};


// status of local ship that is transmitted to remote players -----------------
//
struct ShipRemInfo {

	Xmatrx 		ObjPosition;		// 12 * 4 = 48
	word   		CurDamage;			// 2
	word   		CurShield;			// 2
	fixed_t		CurSpeed;			// 4
	bams_t 		CurYaw;				// 4
	bams_t 		CurPitch;			// 4
	bams_t 		CurRoll;			// 4
	geomv_t		CurSlideHorz;		// 4
	geomv_t		CurSlideVert;		// 4
	int         NumMissls;          // 4
	int         NumHomMissls;       // 4
	int         NumMines;           // 4
    int         NumPartMissls;      // 4
};



// info about ship that should be created on remote host ----------------------
//
struct ShipCreateInfo {

	dword		ShipIndex;
	Xmatrx 		ObjPosition;
};


// server properties that are returned in ping packets ------------------------
//
struct ServerInfo {

	char 		name[ 32 ];
	byte		portlo;
	byte		porthi;
	byte		_padding[ 42 ];
};

//NOTE:
// sizeof( ServerInfo ) must be <= sizeof( ShipRemInfo )



// ----------------------------------------------------------------------------
// PEER protocol revisions:
// ----------------------------------------------------------------------------
//
// 0.1	build 0190		NetGameData
// 0.2  build 0196		( maxplayers set to 8 ) OldNetGameData = NetGameData from 0190
// 0.3  build 0198		complete new packet handling ( NetPacket{External} )
// 0.4  build 0198		CRC stored in packets

// parsec peer-to-peer protocol version number --------------------------------
//
#define P2P_PROTOCOL_MAJOR			0
#define P2P_PROTOCOL_MINOR			4


//NOTE: internal NetPackets are those that are used by all network/game functions
//      except the ones actually sending and receiving packets over the wire


//NOTE: As we want to have only some fields in the structure inherited, we
//      can not use standard C++ inheritance here. Instead we define the
//      structures such, that they are compatible in the (shared) sections.
//		The main reason for this is the variable sized remote event list

//NOTE: if you change anything in the "shared" sections of NetPacket, be sure
//		to do the same in NetPacket_GMSV and NetPacket_PEER

// common base structure for internal ( in-memory ) packet structure ( protocol independent )
//
struct NetPacket {

	//------------------------------------------------------------------------
	// header	( shared )									// = 128
	//------------------------------------------------------------------------
	int			SendPlayerId;								// 4
	dword		MessageId;									// 4

	int			Command;									// 4
	int			params[ 29 ];								// 116

	//------------------------------------------------------------------------
	// payload	( differs )									// = 128
	//------------------------------------------------------------------------
	
	byte		payload_pad[ 128 ];							// 128

	//------------------------------------------------------------------------
	// remote event list ( shared )							/// NET_MAX_DATA_LENGTH ( 1400 or 546 ) - 256 = 1144 or 290
	//------------------------------------------------------------------------
	//size_t		RE_ListSize;								// 4
	//dword		RE_List;									// 4 ( RE_Header + 2 )
	size_t test1;
	dword  test2;
};

// interal ( in-memory ) packet structure when using the gameserver protocol --
//
struct NetPacket_GMSV  {

	//------------------------------------------------------------------------
	// header	( shared )									// = 128
	//------------------------------------------------------------------------
	int			SendPlayerId;								// 4
	dword		MessageId;									// 4
	
	int			Command;									// 4		
//	int			removeme_params[ 29 ];						// 116		//FIXME: not needed in GMSV protocol
	
	//------------------------------------------------------------------------
	// payload	( differs )									// = 128
	//------------------------------------------------------------------------
	dword		ReliableMessageId;							// 4
	dword		AckMessageId;								// 4
	dword		AckReliableMessageId;						// 4

//	byte		payload_pad[ 128 - 3 * sizeof( dword ) ];	// 112		//FIXME: get rid of this 

	//------------------------------------------------------------------------
	// remote event list ( shared )
	//------------------------------------------------------------------------
	size_t		RE_ListSize;								// 4
	dword		RE_List;									// 4 ( RE_Header + 2 )
};


// interal ( in-memory ) packet structure when using the peer-to-peer protocol
//
struct NetPacket_PEER {

	//------------------------------------------------------------------------
	// header	( shared )									// = 128
	//------------------------------------------------------------------------
	int			SendPlayerId;								// 4
	dword		MessageId;									// 4
	
	int			Command;									// 4
	int			params[ 29 ];								// 116
	
	//------------------------------------------------------------------------
	// payload	( differs )									// = 128
	//------------------------------------------------------------------------
	int			DestPlayerId;								// 4
	
	byte		Universe;									// 1
	byte		NumPlayers;									// 1
	byte		_padding1[ 2 ];								// 2
	byte		PlayerKills[ MAX_NET_ALLOC_SLOTS ];			// 16
	
	ShipRemInfo ShipInfo;									// 76 
	
	int			GameTime;									// 4

	byte		payload_pad[ 128 - 104 ];					// 24

	//------------------------------------------------------------------------
	// remote event list ( shared )							/// NET_MAX_DATA_LENGTH ( 1400 or 546 ) - 256 = 1144 or 290
	//------------------------------------------------------------------------
	size_t		RE_ListSize;								// 4
	dword		RE_List;									// 4 ( RE_Header + 2 )
};

//NOTE: external NetPackets are those that are actually sent over the wire or
//      stored in recorded demos

// common base structure for external network packets -------------------------
//
struct NetPacketExternal {

	// header -------------------------
	char		Signature[ 1 ];
	
};

// external packet format for gameserver protocol -----------------------------
//
struct NetPacketExternal_GMSV : NetPacketExternal {

	// header -------------------------
	char		Signature2[ 3 ];
	word		Protocol;
	byte		MajorVersion;
	byte		MinorVersion;

	dword		crc32;
	//FIXME: padding ?????
	
	// payload ------------------------
	int			SendPlayerId;

	dword		MessageId;
	dword		ReliableMessageId;
	dword		AckMessageId;
	dword		AckReliableMessageId;

	byte		Command;
//	signed char removeme_param1; // do we need these in gameserver protocol??
//	signed char removeme_param2;
//	signed char removeme_param3;
//	int 		removeme_param4;

	dword		RE_List;
};


// external DEMO packet format for gameserver protocol ------------------------
//
typedef struct NetPacketExternal_GMSV NetPacketExternal_DEMO_GMSV;


// external packet format for peer-to-peer protocol ---------------------------
//
struct NetPacketExternal_PEER : NetPacketExternal {

	// header -------------------------
	char		Signature2[ 3 ];
	word		Protocol;
	byte		MajorVersion;
	byte		MinorVersion;

	dword		crc32;
	//FIXME: padding ?????

	// payload ------------------------
	dword		MessageId;

	byte		Command;
	signed char param1;
	signed char param2;
	signed char param3;
	int 		param4;

	byte		Universe;
	byte		NumPlayers;
	signed char SendPlayerId;
	signed char DestPlayerId;
	
	byte		PlayerKills[ MAX_NET_ALLOC_SLOTS ];

	ShipRemInfo ShipInfo;

	int			GameTime;

	dword		RE_List;
};

// external DEMO packet format for peer-to-peer protocol ----------------------
//
struct NetPacketExternal_DEMO_PEER : NetPacketExternal {

	// header -------------------------
	char		Signature2[ 3 ];
	word		Protocol;
	byte		MajorVersion;
	byte		MinorVersion;

	// additional header for DEMO -----
	size_t		pktsize;

	dword		crc32;						// CRC over the whole packet
	dword       crc_header;					// CRC over the header ( not including this field )
	
	// payload ------------------------
	dword		MessageId;
	
	byte		Command;
	signed char param1;
	signed char param2;
	signed char param3;
	int 		param4;
	
	byte		Universe;
	byte		NumPlayers;
	signed char SendPlayerId;
	signed char DestPlayerId;
	
	byte		PlayerKills[ MAX_NET_ALLOC_SLOTS ];
	
	ShipRemInfo ShipInfo;
	
	int			GameTime;
	
	dword		RE_List;
};

// external packet format for legacy recorded demos ( stored in demos <= 0190 ) -------
//
struct NetPacketExternal_DEMO_PEER_0190 : NetPacketExternal {

	// header -------------------------
	char		Signature2[ PACKET_SIGNATURE_SIZE - 1 ];

	// payload ------------------------
	dword		MessageId;

	byte		Command;
	signed char param1;
	signed char param2;
	signed char param3;
	int 		param4;

	byte		Universe;
	byte		NumPlayers;
	signed char SendPlayerId;
	signed char DestPlayerId;

	byte		PlayerKills[ MAX_NET_IPX_PEER_PLAYERS ];

	ShipRemInfo ShipInfo;

	int			GameTime;

	dword		RE_List;
};

//#define NETGAMEDATA_SIZE		NET_MAX_DATA_LENGTH

/*
#ifndef _NEW_NETPACKET

// game data for network transfer ---------------------------------------------
//
struct NetGameData {

	char		Signature[ PACKET_SIGNATURE_SIZE ];

	dword		MessageId;

	byte		Command;
	signed char param1;
	signed char param2;
	signed char param3;
	int 		param4;

	byte		Universe;
	byte		NumPlayers;
	signed char SendPlayerId;
	signed char DestPlayerId;

	byte		PlayerKills[ MAX_NET_ALLOC_SLOTS ];

	ShipRemInfo ShipInfo;

	int			GameTime;

	dword		RE_List;
};

// OLD game data for network transfer -----------------------------------------
//
struct OldNetGameData {

	char		Signature[ PACKET_SIGNATURE_SIZE ];

	dword		MessageId;

	byte		Command;
	signed char param1;
	signed char param2;
	signed char param3;
	int 		param4;

	byte		Universe;
	byte		NumPlayers;
	signed char SendPlayerId;
	signed char DestPlayerId;

	byte		PlayerKills[ MAX_NET_IPX_PEER_PLAYERS ];

	ShipRemInfo ShipInfo;

	int			GameTime;

	dword		RE_List;
};

#endif // !_NEW_NETPACKET
*/


// maximum available space for remote event-list ------------------------------
//
#define RE_LIST_MAXAVAIL		( NETs_RmEvList_GetMaxSize() )
#define RE_LIST_ALLOC_SIZE		( NET_ALLOC_DATA_LENGTH + sizeof( RE_Header ) )


// packet types (commands) ----------------------------------------------------
//
#define PKTP_CONNECT			0x00	// initial request for connection	(peer-to-peer only)
#define PKTP_CONNECT_REPLY		0x01	// reply to connect request			(peer-to-peer only)
#define PKTP_DISCONNECT			0x02	// disconnect entirely				(peer-to-peer only)
#define PKTP_SLOT_REQUEST		0x03	// slave requests slot				(peer-to-peer only)
#define PKTP_SUBDUE_SLAVE		0x04	// make sure slave subjects himself	(peer-to-peer only)

#define PKTP_JOIN				0x05	// join game (connection already up)		(peer-to-peer only)
#define PKTP_UNJOIN				0x06	// unjoin game (exit to entry-mode)			(peer-to-peer only)
#define PKTP_GAME_STATE			0x07	// current game state update ( joined )		(peer-to-peer only)
#define PKTP_NODE_ALIVE			0x08	// prevent being kicked out  ( unjoined )	(peer-to-peer only)
//#define PKTP_PING				0x09	// ping packet								(peer-to-peer only)

#define PKTP_COMMAND			0x20	// client/server command            ( C <-> S ) 
#define PKTP_STREAM				0x21    // client/server stream				( C <-> S )


// object list identifiers ----------------------------------------------------
//
#define SHIP_LIST				0x00
#define LASER_LIST				0x01
#define MISSL_LIST				0x02
#define EXTRA_LIST				0x03
#define CUSTM_LIST				0x04


// particle object types ------------------------------------------------------
//
#define POBJ_ENERGYFIELD		0x01
#define POBJ_MEGASHIELD			0x02
#define POBJ_SPREADFIRE			0x03


// weapon status flags --------------------------------------------------------
//
#define WPSTATE_OFF				0x00
#define WPSTATE_ON				0x01


// player connect/join status -------------------------------------------------
//
#define PLAYER_INACTIVE			0x00
#define PLAYER_CONNECTED		0x01
#define PLAYER_JOINED			0x03


// cause of return to entry-mode ----------------------------------------------
//
#define USER_EXIT				0x00
#define SHIP_DOWNED 			0x01


// remote event control blocks ------------------------------------------------
//
enum re_events {

	RE_EMPTY,			// 0x00
	RE_DELETED,			// 0x01
	RE_CREATEOBJECT, 		// 0x02
	RE_CREATELASER,		// 0x03
	RE_CREATEMISSILE,		// 0x04
	RE_CREATEEXTRA,		// 0x05
	RE_KILLOBJECT,		// 0x06
	RE_SENDTEXT, 			// 0x07
	RE_PLAYERNAME,		// 0x08
	RE_PARTICLEOBJECT,		// 0x09
	RE_PLAYERLIST,		// 0x0a
	RE_CONNECTQUEUE,		// 0x0b
	RE_WEAPONSTATE,		// 0x0c
	RE_STATESYNC,			// 0x0d
	RE_CREATESWARM,		// 0x0e
	RE_CREATEEMP,			// 0x0f
	RE_OWNERSECTION,		// 0x10		// 16
	RE_PLAYERSTATUS,		// 0x11		// 17
	RE_PLAYERANDSHIPSTATUS,	// 0x12		// 18
	RE_KILLSTATS,			// 0x13		// 19
	RE_GAMESTATE,			// 0x14		// 20
	RE_COMMANDINFO,		// 0x15		// 21
	RE_CLIENTINFO,		// 0x16		// 22
	RE_CREATEEXTRA2,		// 0x17		// 23 
	RE_IPV4SERVERINFO,		// 0x18		// 24
	RE_SERVERLINKINFO,		// 0x19		// 25
	RE_MAPOBJECT,			// 0x1a		// 26
	RE_STARGATE,			// 0x1b		// 27
       RE_CREATEMINE,
	RE_NUMEVENTS
};
	
// used if remote event size > 255
#define RE_BLOCKSIZE_INVALID	0x00

// header every block starts with
struct RE_Header {

	byte		RE_Type;      //1
	byte		RE_BlockSize; //1
}; //Size: 2

// generic object creation
struct RE_CreateObject : RE_Header { //2

	word		ObjectClass; //2
	dword		HostObjId; //4
	Xmatrx		ObjPosition; //48
	dword		Flags; //4
}; //Size: 60

// laser object creation
struct RE_CreateLaser : RE_Header { //2 

	word		ObjectClass; //2
	dword		HostObjId; //4
	Xmatrx		ObjPosition; //48
	Vertex3 	DirectionVec; //16
}; //72

// missile object creation
struct RE_CreateMissile : RE_Header { //2

	word		ObjectClass; //2
	dword		HostObjId; //4
	Xmatrx		ObjPosition; //48
	Vertex3 	DirectionVec; //16
	dword		TargetHostObjId; //4
}; //76

// extra object creation
struct RE_CreateExtra : RE_Header { //2

	word		ExtraIndex; //2
	dword		HostObjId; //4
	Xmatrx		ObjPosition; //28
}; //36

// extra object creation
struct RE_CreateExtra2 : RE_Header { //2

	word		ExtraIndex; //2
	dword		HostObjId; //4
	Xmatrx		ObjPosition; //48
	Vector3     DriftVec; //16
	int			DriftTimeout; //4
}; //76

// Mine object creation
struct RE_CreateMine : RE_Header { //2
    word            ExtraIndex; //2
    dword           HostObjId; //4
    Xmatrx          ObjPosition; //48
}; //56

// object destruction 
struct RE_KillObject : RE_Header { //2

	byte		ListId; //1
	byte		Flags; //1
	dword		HostObjId; //4
}; //8

// arbitrary text
struct RE_SendText : RE_Header { //2

	char		TextStart[1];
}; //3 - 257

// player name
struct RE_PlayerName : RE_Header { //2

	char		PlayerName[ MAX_PLAYER_NAME + 1 ]; //32
}; //34

// particle object creation
struct RE_ParticleObject : RE_Header { //2

	word		ObjectType; //2
	Vertex3 	Origin; //16
}; //20

// list of all remote players
struct RE_PlayerList : RE_Header { //2

	byte			SyncValKillLimit;
	byte			SyncValNebulaId;
	byte			Status[ MAX_NET_IPX_PEER_PLAYERS ];
	node_t			AddressTable[ MAX_NET_IPX_PEER_PLAYERS ];
	char			NameTable[ MAX_NET_IPX_PEER_PLAYERS ][ MAX_PLAYER_NAME + 1 ];
	ShipCreateInfo	ShipInfoTable[ MAX_NET_IPX_PEER_PLAYERS ];
};

// list of remote players trying to connect
struct RE_ConnectQueue : RE_Header {

	short		NumRequests;
	node_t		AddressTable[ MAX_SLOT_REQUESTS ];
	char		NameTable[ MAX_SLOT_REQUESTS ][ MAX_PLAYER_NAME + 1 ];
};

// weapon firing
struct RE_WeaponState : RE_Header { //2

	byte		State; //1
	byte		_dummy; //1
	dword		WeaponMask; //4
//	dword		Specials;		// would break demos
	int 		CurEnergy; //4
    int          SenderId; //4
}; //16

// state synchroniziation
struct RE_StateSync : RE_Header { //2

	byte		StateKey; //1
	byte		StateValue; //1
}; //4 (was 8)

// swarm missile creation
struct RE_CreateSwarm : RE_Header { //2
	Vertex3		Origin; //16
	dword		TargetHostObjId; //4
	dword		RandSeed; //4
    byte        SenderId; //4
}; //30

// emp creation
struct RE_CreateEmp : RE_Header { //2
	byte 			Upgradelevel; //1
	int				SenderId; // 4
}; //7

// owner section
struct RE_OwnerSection : RE_Header { //2

	byte		owner; //1
}; //3

// playerstate
struct RE_PlayerStatus : RE_Header { //2

	word		player_status;	//2
	signed char	params[ 4 ]; //4
	int		objectindex; //4
	byte		senderid; //1
	refframe_t	RefFrame; //4

	// sizeof( RE_PlayerStatus ) = (2) + 2 + 4 + 4 + 4 = 17
};	


#define UF_PROPERTIES		0x0001
#define UF_SPEEDS			0x0002
#define UF_RESYNCPOS		0x0004
#define UF_STATUS			0x0008
#define UF_ALL				0xFFFF

// full ship & player state 
struct RE_PlayerAndShipStatus : RE_PlayerStatus //20
{
	Xmatrx 		ObjPosition;	// 48
	word   		CurDamage;		// 2
	word   		CurShield;		// 2
	fixed_t		CurSpeed;		// 4
	bams_t 		CurYaw;		    // 4
	bams_t 		CurPitch;		// 4
	bams_t 		CurRoll;		// 4
	geomv_t		CurSlideHorz;	// 4
	geomv_t		CurSlideVert;	// 4
	int			CurEnergy;		// 4
	byte 		NumMissls;      // 1
    byte        NumHomMissls;   // 1
    byte        NumMines;       // 1
    byte        NumPartMissls;  // 1
    byte		UpdateFlags;	// 1

	// sizeof( RE_PlayerAndShipStatus ) = (17) + 85 = 102
};


// killstats 
struct RE_KillStats : RE_Header { //2
	byte	PlayerKills[ MAX_NET_ALLOC_SLOTS ]; //16
	// 18
};

// gamestate
struct RE_GameState : RE_Header { //2
	int		GameTime; //4
	// 6
};

// max. length of a command ---------------------------------------------------
#define MAX_RE_COMMANDINFO_COMMAND_LEN		254 - 1 - 2 /*header*/ - 1 /*code*/

// command ( GMSV mode only )
struct RE_CommandInfo : RE_Header { //2
	byte code; //1
	//char command[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
	char command[1]; //?
}; //4 to 250

#define PACK_SERVERRATE( r )				( (byte)(r / 100) )
#define UNPACK_SERVERRATE( r )				( (r) * 100 )

// clientinfo ( GMSV mode only )
struct RE_ClientInfo : RE_Header {
	byte client_sendfreq;		// packets per sec.
	byte server_sendrate;		// bytes per sec.
	// 4
};


// serverinfo about a IP4 server 
struct RE_IPv4ServerInfo : RE_Header {
	byte	node[ 6 ];
	word	flags;
	word	serverid;
	int		xpos;
	int		ypos;

	// sizeof( RE_IPv4ServerInfo ) = (2) + 6 + 2 + 2 + 4 + 4 = 20
};

// serverlink info flags ------------------------------------------------------
//
#define SERVERLINKINFO_1_TO_2	0x01		// link is  1 --> 2
#define SERVERLINKINFO_2_TO_1	0x02		// link is  1 <-- 2
#define SERVERLINKINFO_BOTH		0x03		// link is  1 <-> 2

// linkinfo between 2 servers -------------------------------------------------
//
struct RE_ServerLinkInfo : RE_Header {
	word	flags;
	word	serverid1;
	word	serverid2;

	// sizeof( RE_ServerLinkInfo ) = (2) + 2 + 2 + 2 = 8
};


// map object ----------------------------------------------------------------- 
//
struct RE_MapObject : RE_Header {
	word		map_objectid;
	char		name[ MAX_MAP_OBJ_NAME + 1 ];
	int  		xpos;
	int  		ypos;
	int	 		w;
	int  		h;
	char 		texname[ MAX_TEXNAME + 1 ];

	// sizeof( RE_MapObject ) = (2) + 2 + 32 + 4 + 4 + 4 + 4 + 32 = 84
};

// stargate properties --------------------------------------------------------
//
struct RE_Stargate : RE_Header {
	word	serverid;			// 2
	float	pos[ 3 ];			// 12
	float	dir[ 3 ];			// 12
	bams_t	rotspeed;			// 4
	float radius;				// 4
	float	actdistance;		// 4
	float	partvel;			// 4
	float	modulrad1;			// 4
	float	modulrad2;			// 4
	char	flare_name		[ MAX_TEXNAME     + 1 ]; // 32
	char	interior_name	[ MAX_TEXNAME	  + 1 ]; // 32
	word	numpartactive;		// 2
	word	actcyllen;			// 2
	word	modulspeed;			// 2
	byte	acttime;			// 1
	byte	autoactivate;		// 1
	byte	dormant;			// 1
	byte	active;				// 1
	byte	_mksz128[ 2 ];		// 2

	// sizeof( RE_Stargate ) = 128
};


//NOTE:
// new remote event structures must ensure proper alignment
// after the two leading header bytes, which usually means
// using two single bytes or a word as first field.


// make object id unique in network game by appending local player's id -------
//
#ifndef PARSEC_MASTER

	#ifdef PARSEC_SERVER

		inline dword CreateGlobalObjId( dword localobjid, dword dwOwner )
		{
			ASSERT( ( ( dwOwner >= 0 ) && ( dwOwner < MAX_NET_ALLOC_SLOTS ) ) || ( dwOwner == PLAYERID_SERVER ) );
			return ( ( dwOwner << 16 ) | ( localobjid & 0xffff ) );
		}

	#else

		inline dword CreateGlobalObjId( dword localobjid )
		{
			ASSERT( !NetConnected || ( ( LocalPlayerId >= 0 ) && ( LocalPlayerId < MAX_NET_ALLOC_SLOTS ) ) );
			return ( ( LocalPlayerId << 16 ) | ( localobjid & 0xffff ) );
		}

	#endif // PARSEC_SERVER

#endif // PARSEC_MASTER


// calc host object-id for ship of remote player (ship object id is 0) --------
//
//#define ShipHostObjId( playerid )			( playerid << 16 )
inline dword ShipHostObjId( dword playerid ) 
{ 
	return ( playerid << 16 ); 
}


// retrieve owner from HostOjbNumber ------------------------------------------
// 
inline dword GetOwnerFromHostOjbNumber( dword _HostObjNumber )
{
	return _HostObjNumber >> 16;
}

// determine owner of object (remote player id) -------------------------------
//
inline dword GetObjectOwner( const GenObject *obj )
{
	return GetOwnerFromHostOjbNumber( obj->HostObjNumber );
}

#ifdef PARSEC_CLIENT

	// include system-specific subsystem prototypes
	#include "net_subh.h"

#else // !PARSEC_CLIENT

	// include system-specific subsystem prototypes
	#include "net_subh_sv.h"

#endif // !PARSEC_CLIENT


#endif // _NET_DEFS_H_