1

#ifndef NETWORK_DATA_H

     2

#define NETWORK_DATA_H

     3

     4

#include "ttd.h"

     5

#include "network.h"

     6

     7

// Is the network enabled?

     8

#ifdef ENABLE_NETWORK

     9

    10

#define SEND_MTU 1460

    11

#define MAX_TEXT_MSG_LEN 1024 /* long long long long sentences :-) */

    12

    13

// The client-info-server-index is always 1

    14

#define NETWORK_SERVER_INDEX 1

    15

#define NETWORK_EMPTY_INDEX 0

    16

    17

// What version of game-info do we use?

    18

#define NETWORK_GAME_INFO_VERSION 1

    19

// What version of company info is this?

    20

#define NETWORK_COMPANY_INFO_VERSION 1

    21

    22

typedef uint16 PacketSize;

    23

    24

typedef struct Packet {

    25

	struct Packet *next;

    26

	PacketSize size;

    27

	PacketSize pos;

    28

	byte buffer[SEND_MTU];

    29

} Packet;

    30

    31

typedef struct CommandPacket {

    32

	struct CommandPacket *next;

    33

	byte player;

    34

	uint32 cmd;

    35

	uint32 p1;

    36

	uint32 p2;

    37

	uint32 tile; // Always make it uint32, so it is bigmap compatible

    38

	uint32 dp[20]; // decode_params

    39

	uint32 frame; // In which frame must this packet be executed?

    40

	byte callback;

    41

} CommandPacket;

    42

    43

typedef enum {

    44

	STATUS_INACTIVE,

    45

	STATUS_AUTH, // This means that the client is authorized

    46

	STATUS_MAP_WAIT, // This means that the client is put on hold because someone else is getting the map

    47

	STATUS_MAP,

    48

	STATUS_DONE_MAP,

    49

	STATUS_PRE_ACTIVE,

    50

	STATUS_ACTIVE,

    51

} ClientStatus;

    52

    53

typedef enum {

    54

	MAP_PACKET_START,

    55

	MAP_PACKET_NORMAL,

    56

	MAP_PACKET_PATCH,

    57

	MAP_PACKET_END,

    58

} MapPacket;

    59

    60

typedef enum {

    61

	NETWORK_RECV_STATUS_OKAY,

    62

	NETWORK_RECV_STATUS_DESYNC,

    63

	NETWORK_RECV_STATUS_SAVEGAME,

    64

	NETWORK_RECV_STATUS_CONN_LOST,

    65

	NETWORK_RECV_STATUS_MALFORMED_PACKET,

    66

	NETWORK_RECV_STATUS_SERVER_ERROR, // The server told us we made an error

    67

	NETWORK_RECV_STATUS_SERVER_FULL,

    68

	NETWORK_RECV_STATUS_CLOSE_QUERY, // Done quering the server

    69

} NetworkRecvStatus;

    70

    71

typedef enum {

    72

	NETWORK_ERROR_GENERAL, // Try to use thisone like never

    73

    74

	// Signals from clients

    75

	NETWORK_ERROR_DESYNC,

    76

	NETWORK_ERROR_SAVEGAME_FAILED,

    77

	NETWORK_ERROR_CONNECTION_LOST,

    78

	NETWORK_ERROR_ILLEGAL_PACKET,

    79

    80

	// Signals from servers

    81

	NETWORK_ERROR_NOT_AUTHORIZED,

    82

	NETWORK_ERROR_NOT_EXPECTED,

    83

	NETWORK_ERROR_WRONG_REVISION,

    84

	NETWORK_ERROR_NAME_IN_USE,

    85

	NETWORK_ERROR_WRONG_PASSWORD,

    86

	NETWORK_ERROR_PLAYER_MISMATCH, // Happens in CLIENT_COMMAND

    87

	NETWORK_ERROR_KICKED,

    88

} NetworkErrorCode;

    89

    90

// Actions that can be used for NetworkTextMessage

    91

typedef enum {

    92

	NETWORK_ACTION_JOIN_LEAVE,

    93

	NETWORK_ACTION_CHAT,

    94

	NETWORK_ACTION_CHAT_PLAYER,

    95

	NETWORK_ACTION_CHAT_CLIENT,

    96

	NETWORK_ACTION_CHAT_TO_CLIENT,

    97

	NETWORK_ACTION_CHAT_TO_PLAYER,

    98

	NETWORK_ACTION_GIVE_MONEY,

    99

	NETWORK_ACTION_NAME_CHANGE,

   100

} NetworkAction;

   101

   102

typedef enum {

   103

	NETWORK_GAME_PASSWORD,

   104

	NETWORK_COMPANY_PASSWORD,

   105

} NetworkPasswordType;

   106

   107

// To keep the clients all together

   108

typedef struct ClientState {

   109

	int socket;

   110

	uint16 index;

   111

	uint32 last_frame;

   112

	uint32 last_frame_server;

   113

	byte lag_test; // This byte is used for lag-testing the client

   114

   115

	ClientStatus status;

   116

	bool writable; // is client ready to write to?

   117

	bool quited;

   118

   119

	Packet *packet_queue; // Packets that are awaiting delivery

   120

	Packet *packet_recv; // Partially received packet

   121

   122

	CommandPacket *command_queue; // The command-queue awaiting delivery

   123

} ClientState;

   124

   125

// What packet types are there

   126

// WARNING: The first 3 packets can NEVER change order again

   127

//   it protects old clients from joining newer servers (because SERVER_ERROR

   128

//   is the respond to a wrong revision)

   129

typedef enum {

   130

	PACKET_SERVER_FULL,

   131

	PACKET_CLIENT_JOIN,

   132

	PACKET_SERVER_ERROR,

   133

	PACKET_CLIENT_COMPANY_INFO,

   134

	PACKET_SERVER_COMPANY_INFO,

   135

	PACKET_SERVER_CLIENT_INFO,

   136

	PACKET_SERVER_NEED_PASSWORD,

   137

	PACKET_CLIENT_PASSWORD,

   138

	PACKET_SERVER_WELCOME,

   139

	PACKET_CLIENT_GETMAP,

   140

	PACKET_SERVER_WAIT,

   141

	PACKET_SERVER_MAP,

   142

	PACKET_CLIENT_MAP_OK,

   143

	PACKET_SERVER_JOIN,

   144

	PACKET_SERVER_FRAME,

   145

	PACKET_SERVER_SYNC,

   146

	PACKET_CLIENT_ACK,

   147

	PACKET_CLIENT_COMMAND,

   148

	PACKET_SERVER_COMMAND,

   149

	PACKET_CLIENT_CHAT,

   150

	PACKET_SERVER_CHAT,

   151

	PACKET_CLIENT_SET_PASSWORD,

   152

	PACKET_CLIENT_SET_NAME,

   153

	PACKET_CLIENT_QUIT,

   154

	PACKET_CLIENT_ERROR,

   155

	PACKET_SERVER_QUIT,

   156

	PACKET_SERVER_ERROR_QUIT,

   157

	PACKET_SERVER_SHUTDOWN,

   158

	PACKET_SERVER_NEWGAME,

   159

	PACKET_END // Should ALWAYS be on the end of this list!! (period)

   160

} PacketType;

   161

   162

typedef enum {

   163

	DESTTYPE_BROADCAST,

   164

	DESTTYPE_PLAYER,

   165

	DESTTYPE_CLIENT

   166

} DestType;

   167

   168

CommandPacket *_local_command_queue;

   169

   170

SOCKET _udp_client_socket; // udp client socket

   171

   172

// Here we keep track of the clients

   173

//  (and the client uses [0] for his own communication)

   174

ClientState _clients[MAX_CLIENTS];

   175

#define DEREF_CLIENT(i) (&_clients[i])

   176

// This returns the NetworkClientInfo from a ClientState

   177

#define DEREF_CLIENT_INFO(cs) (&_network_client_info[cs - _clients])

   178

   179

// Macros to make life a bit more easier

   180

#define DEF_CLIENT_RECEIVE_COMMAND(type) NetworkRecvStatus NetworkPacketReceive_ ## type ## _command(Packet *p)

   181

#define DEF_CLIENT_SEND_COMMAND(type) void NetworkPacketSend_ ## type ## _command(void)

   182

#define DEF_CLIENT_SEND_COMMAND_PARAM(type) void NetworkPacketSend_ ## type ## _command

   183

#define DEF_SERVER_RECEIVE_COMMAND(type) void NetworkPacketReceive_ ## type ## _command(ClientState *cs, Packet *p)

   184

#define DEF_SERVER_SEND_COMMAND(type) void NetworkPacketSend_ ## type ## _command(ClientState *cs)

   185

#define DEF_SERVER_SEND_COMMAND_PARAM(type) void NetworkPacketSend_ ## type ## _command

   186

   187

#define SEND_COMMAND(type) NetworkPacketSend_ ## type ## _command

   188

#define RECEIVE_COMMAND(type) NetworkPacketReceive_ ## type ## _command

   189

   190

#define FOR_ALL_CLIENTS(cs) for (cs = _clients; cs != &_clients[MAX_CLIENTS] && cs->socket != INVALID_SOCKET; cs++)

   191

   192

Packet *NetworkSend_Init(PacketType type);

   193

void NetworkSend_uint8(Packet *packet, uint8 data);

   194

void NetworkSend_uint16(Packet *packet, uint16 data);

   195

void NetworkSend_uint32(Packet *packet, uint32 data);

   196

void NetworkSend_uint64(Packet *packet, uint64 data);

   197

void NetworkSend_string(Packet *packet, const char* data);

   198

void NetworkSend_Packet(Packet *packet, ClientState *cs);

   199

   200

uint8 NetworkRecv_uint8(Packet *packet);

   201

uint16 NetworkRecv_uint16(Packet *packet);

   202

uint32 NetworkRecv_uint32(Packet *packet);

   203

uint64 NetworkRecv_uint64(Packet *packet);

   204

void NetworkRecv_string(Packet *packet, char* buffer, size_t size);

   205

Packet *NetworkRecv_Packet(ClientState *cs, NetworkRecvStatus *status);

   206

   207

bool NetworkSend_Packets(ClientState *cs);

   208

void NetworkExecuteCommand(CommandPacket *cp);

   209

void NetworkAddCommandQueue(ClientState *cs, CommandPacket *cp);

   210

   211

// from network.c

   212

void CloseClient(ClientState *cs);

   214

void NetworkGetClientName(char *clientname, size_t size, ClientState *cs);

   215

uint NetworkCalculateLag(const ClientState *cs);

   216

byte NetworkGetCurrentLanguageIndex();

   217

NetworkClientInfo *NetworkFindClientInfoFromIndex(uint16 client_index);

   218

ClientState *NetworkFindClientStateFromIndex(uint16 client_index);

   219

unsigned long NetworkResolveHost(const char *hostname);

   220

   221

#endif /* ENABLE_NETWORK */

   222

   223

#endif // NETWORK_DATA_H