openttd-mini: comparison src/network/network

equal deleted inserted replaced

-:6f5ece1805fe
+:135d10dd7219
 	//    String: The unique id of the client
 	//
 	if (ci->client_index != NETWORK_EMPTY_INDEX) {
 		Packet *p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);
-		NetworkSend_uint16(p, ci->client_index);
+		p->Send_uint16(ci->client_index);
-		NetworkSend_uint8 (p, ci->client_playas);
+		p->Send_uint8 (ci->client_playas);
-		NetworkSend_string(p, ci->client_name);
+		p->Send_string(ci->client_name);
-		NetworkSend_string(p, ci->unique_id);
+		p->Send_string(ci->unique_id);
 		NetworkSend_Packet(p, cs);
 	}
 }
 	byte active = ActivePlayerCount();
 	if (active == 0) {
 		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);
-		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);
+		p->Send_uint8 (NETWORK_COMPANY_INFO_VERSION);
-		NetworkSend_uint8 (p, active);
+		p->Send_uint8 (active);
 		NetworkSend_Packet(p, cs);
 		return;
 	}
 	FOR_ALL_PLAYERS(player) {
 		if (!player->is_active) continue;
 		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);
-		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);
+		p->Send_uint8 (NETWORK_COMPANY_INFO_VERSION);
-		NetworkSend_uint8 (p, active);
+		p->Send_uint8 (active);
-		NetworkSend_uint8 (p, player->index);
+		p->Send_uint8 (player->index);
-		NetworkSend_string(p, _network_player_info[player->index].company_name);
+		p->Send_string(_network_player_info[player->index].company_name);
-		NetworkSend_uint32(p, _network_player_info[player->index].inaugurated_year);
+		p->Send_uint32(_network_player_info[player->index].inaugurated_year);
-		NetworkSend_uint64(p, _network_player_info[player->index].company_value);
+		p->Send_uint64(_network_player_info[player->index].company_value);
-		NetworkSend_uint64(p, _network_player_info[player->index].money);
+		p->Send_uint64(_network_player_info[player->index].money);
-		NetworkSend_uint64(p, _network_player_info[player->index].income);
+		p->Send_uint64(_network_player_info[player->index].income);
-		NetworkSend_uint16(p, _network_player_info[player->index].performance);
+		p->Send_uint16(_network_player_info[player->index].performance);
 		/* Send 1 if there is a passord for the company else send 0 */
-		if (_network_player_info[player->index].password[0] != '\0') {
+		p->Send_uint8(StrEmpty(_network_player_info[player->index].password) ? 0 : 1);
-			NetworkSend_uint8(p, 1);
+		for (i = 0; i < NETWORK_VEHICLE_TYPES; i++) {
+			p->Send_uint16(_network_player_info[player->index].num_vehicle[i]);
+		}
+		for (i = 0; i < NETWORK_STATION_TYPES; i++) {
+			p->Send_uint16(_network_player_info[player->index].num_station[i]);
+		}
+		if (_network_player_info[player->index].players[0] == '\0') {
+			p->Send_string("<none>");
 		} else {
-			NetworkSend_uint8(p, 0);
+			p->Send_string(_network_player_info[player->index].players);
-		}
-		for (i = 0; i < NETWORK_VEHICLE_TYPES; i++) {
-			NetworkSend_uint16(p, _network_player_info[player->index].num_vehicle[i]);
-		}
-		for (i = 0; i < NETWORK_STATION_TYPES; i++) {
-			NetworkSend_uint16(p, _network_player_info[player->index].num_station[i]);
-		}
-		if (_network_player_info[player->index].players[0] == '\0') {
-			NetworkSend_string(p, "<none>");
-		} else {
-			NetworkSend_string(p, _network_player_info[player->index].players);
 		}
 		NetworkSend_Packet(p, cs);
 	}
 	p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);
-	NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);
+	p->Send_uint8 (NETWORK_COMPANY_INFO_VERSION);
-	NetworkSend_uint8 (p, 0);
+	p->Send_uint8 (0);
 	NetworkSend_Packet(p, cs);
 }
 DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR)(NetworkTCPSocketHandler *cs, NetworkErrorCode error)
 	//
 	char str[100];
 	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);
-	NetworkSend_uint8(p, error);
+	p->Send_uint8(error);
 	NetworkSend_Packet(p, cs);
 	GetNetworkErrorMsg(str, error, lastof(str));
 	// Only send when the current client was in game
 	const GRFConfig *c;
 	uint grf_count = 0;
 	for (c = _grfconfig; c != NULL; c = c->next) grf_count++;
-	NetworkSend_uint8 (p, grf_count);
+	p->Send_uint8 (grf_count);
 	for (c = _grfconfig; c != NULL; c = c->next) {
 		cs->Send_GRFIdentifier(p, c);
 	}
 	NetworkSend_Packet(p, cs);
 	// Data:
 	//    uint8:  Type of password
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);
-	NetworkSend_uint8(p, type);
+	p->Send_uint8(type);
 	NetworkSend_Packet(p, cs);
 }
 DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)
 {
 	cs->status = STATUS_AUTH;
 	_network_game_info.clients_on++;
 	p = NetworkSend_Init(PACKET_SERVER_WELCOME);
-	NetworkSend_uint16(p, cs->index);
+	p->Send_uint16(cs->index);
 	NetworkSend_Packet(p, cs);
 		// Transmit info about all the active clients
 	FOR_ALL_CLIENTS(new_cs) {
 		if (new_cs != cs && new_cs->status > STATUS_AUTH)
 	FOR_ALL_CLIENTS(new_cs) {
 		if (new_cs->status == STATUS_MAP_WAIT) waiting++;
 	}
 	p = NetworkSend_Init(PACKET_SERVER_WAIT);
-	NetworkSend_uint8(p, waiting);
+	p->Send_uint8(waiting);
 	NetworkSend_Packet(p, cs);
 }
 // This sends the map to the client
 DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)
 		if (ftell(file_pointer) == 0) error("network savedump failed - zero sized savegame?");
 		// Now send the _frame_counter and how many packets are coming
 		p = NetworkSend_Init(PACKET_SERVER_MAP);
-		NetworkSend_uint8(p, MAP_PACKET_START);
+		p->Send_uint8 (MAP_PACKET_START);
-		NetworkSend_uint32(p, _frame_counter);
+		p->Send_uint32(_frame_counter);
-		NetworkSend_uint32(p, ftell(file_pointer));
+		p->Send_uint32(ftell(file_pointer));
 		NetworkSend_Packet(p, cs);
 		fseek(file_pointer, 0, SEEK_SET);
 		sent_packets = 4; // We start with trying 4 packets
 	if (cs->status == STATUS_MAP) {
 		uint i;
 		int res;
 		for (i = 0; i < sent_packets; i++) {
 			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);
-			NetworkSend_uint8(p, MAP_PACKET_NORMAL);
+			p->Send_uint8(MAP_PACKET_NORMAL);
 			res = (int)fread(p->buffer + p->size, 1, SEND_MTU - p->size, file_pointer);
 			if (ferror(file_pointer)) error("Error reading temporary network savegame!");
 			p->size += res;
 			NetworkSend_Packet(p, cs);
 			if (feof(file_pointer)) {
 				// Done reading!
 				Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);
-				NetworkSend_uint8(p, MAP_PACKET_END);
+				p->Send_uint8(MAP_PACKET_END);
 				NetworkSend_Packet(p, cs);
 				// Set the status to DONE_MAP, no we will wait for the client
 				//  to send it is ready (maybe that happens like never ;))
 				cs->status = STATUS_DONE_MAP;
 	//    uint16:  Client-Index
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);
-	NetworkSend_uint16(p, client_index);
+	p->Send_uint16(client_index);
 	NetworkSend_Packet(p, cs);
 }
 	//    [uint32: general-seed-2]
 	//      (last two depends on compile-settings, and are not default settings)
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);
-	NetworkSend_uint32(p, _frame_counter);
+	p->Send_uint32(_frame_counter);
-	NetworkSend_uint32(p, _frame_counter_max);
+	p->Send_uint32(_frame_counter_max);
 #ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME
-	NetworkSend_uint32(p, _sync_seed_1);
+	p->Send_uint32(_sync_seed_1);
 #ifdef NETWORK_SEND_DOUBLE_SEED
-	NetworkSend_uint32(p, _sync_seed_2);
+	p->Send_uint32(_sync_seed_2);
 #endif
 #endif
 	NetworkSend_Packet(p, cs);
 }
 	//    [uint32: general-seed-2]
 	//      (last one depends on compile-settings, and are not default settings)
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);
-	NetworkSend_uint32(p, _frame_counter);
+	p->Send_uint32(_frame_counter);
-	NetworkSend_uint32(p, _sync_seed_1);
+	p->Send_uint32(_sync_seed_1);
 #ifdef NETWORK_SEND_DOUBLE_SEED
-	NetworkSend_uint32(p, _sync_seed_2);
+	p->Send_uint32(_sync_seed_2);
 #endif
 	NetworkSend_Packet(p, cs);
 }
 DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_COMMAND)(NetworkTCPSocketHandler *cs, CommandPacket *cp)
 	//    uint32: Frame of execution
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);
-	NetworkSend_uint8(p, cp->player);
+	p->Send_uint8 (cp->player);
-	NetworkSend_uint32(p, cp->cmd);
+	p->Send_uint32(cp->cmd);
-	NetworkSend_uint32(p, cp->p1);
+	p->Send_uint32(cp->p1);
-	NetworkSend_uint32(p, cp->p2);
+	p->Send_uint32(cp->p2);
-	NetworkSend_uint32(p, cp->tile);
+	p->Send_uint32(cp->tile);
-	NetworkSend_string(p, cp->text);
+	p->Send_string(cp->text);
-	NetworkSend_uint8(p, cp->callback);
+	p->Send_uint8 (cp->callback);
-	NetworkSend_uint32(p, cp->frame);
+	p->Send_uint32(cp->frame);
 	NetworkSend_Packet(p, cs);
 }
 DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CHAT)(NetworkTCPSocketHandler *cs, NetworkAction action, uint16 client_index, bool self_send, const char *msg)
 	//    String: Message (max MAX_TEXT_MSG_LEN)
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);
-	NetworkSend_uint8(p, action);
+	p->Send_uint8 (action);
-	NetworkSend_uint16(p, client_index);
+	p->Send_uint16(client_index);
-	NetworkSend_uint8(p, self_send);
+	p->Send_uint8 (self_send);
-	NetworkSend_string(p, msg);
+	p->Send_string(msg);
 	NetworkSend_Packet(p, cs);
 }
 DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR_QUIT)(NetworkTCPSocketHandler *cs, uint16 client_index, NetworkErrorCode errorno)
 	//    uint8:  ErrorID (see network_data.h, NetworkErrorCode)
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR_QUIT);
-	NetworkSend_uint16(p, client_index);
+	p->Send_uint16(client_index);
-	NetworkSend_uint8(p, errorno);
+	p->Send_uint8 (errorno);
 	NetworkSend_Packet(p, cs);
 }
 DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_QUIT)(NetworkTCPSocketHandler *cs, uint16 client_index, const char *leavemsg)
 	//    String: leave-message
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_QUIT);
-	NetworkSend_uint16(p, client_index);
+	p->Send_uint16(client_index);
-	NetworkSend_string(p, leavemsg);
+	p->Send_string(leavemsg);
 	NetworkSend_Packet(p, cs);
 }
 DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SHUTDOWN)
 DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_RCON)(NetworkTCPSocketHandler *cs, uint16 color, const char *command)
 {
 	Packet *p = NetworkSend_Init(PACKET_SERVER_RCON);
-	NetworkSend_uint16(p, color);
+	p->Send_uint16(color);
-	NetworkSend_string(p, command);
+	p->Send_string(command);
 	NetworkSend_Packet(p, cs);
 }
 // **********
 // Receiving functions
 	NetworkClientInfo *ci;
 	PlayerID playas;
 	NetworkLanguage client_lang;
 	char client_revision[NETWORK_REVISION_LENGTH];
-	NetworkRecv_string(cs, p, client_revision, sizeof(client_revision));
+	p->Recv_string(client_revision, sizeof(client_revision));
 #if defined(WITH_REV) || defined(WITH_REV_HACK)
 	// Check if the client has revision control enabled
 	if (strcmp(NOREV_STRING, client_revision) != 0 &&
 			strcmp(_network_game_info.server_revision, client_revision) != 0) {
 		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_WRONG_REVISION);
 		return;
 	}
 #endif
-	NetworkRecv_string(cs, p, name, sizeof(name));
+	p->Recv_string(name, sizeof(name));
-	playas = (Owner)NetworkRecv_uint8(cs, p);
+	playas = (Owner)p->Recv_uint8();
-	client_lang = (NetworkLanguage)NetworkRecv_uint8(cs, p);
+	client_lang = (NetworkLanguage)p->Recv_uint8();
-	NetworkRecv_string(cs, p, unique_id, sizeof(unique_id));
+	p->Recv_string(unique_id, sizeof(unique_id));
 	if (cs->has_quit) return;
 	// join another company does not affect these values
 	switch (playas) {
 {
 	NetworkPasswordType type;
 	char password[NETWORK_PASSWORD_LENGTH];
 	const NetworkClientInfo *ci;
-	type = (NetworkPasswordType)NetworkRecv_uint8(cs, p);
+	type = (NetworkPasswordType)p->Recv_uint8();
-	NetworkRecv_string(cs, p, password, sizeof(password));
+	p->Recv_string(password, sizeof(password));
 	if (cs->status == STATUS_INACTIVE && type == NETWORK_GAME_PASSWORD) {
 		// Check game-password
 		if (strcmp(password, _network_game_info.server_password) != 0) {
 			// Password is invalid
 	if (cs->status < STATUS_DONE_MAP || cs->has_quit) {
 		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);
 		return;
 	}
-	cp->player = (Owner)NetworkRecv_uint8(cs, p);
+	cp->player = (Owner)p->Recv_uint8();
-	cp->cmd    = NetworkRecv_uint32(cs, p);
+	cp->cmd    = p->Recv_uint32();
-	cp->p1     = NetworkRecv_uint32(cs, p);
+	cp->p1     = p->Recv_uint32();
-	cp->p2     = NetworkRecv_uint32(cs, p);
+	cp->p2     = p->Recv_uint32();
-	cp->tile   = NetworkRecv_uint32(cs, p);
+	cp->tile   = p->Recv_uint32();
-	NetworkRecv_string(cs, p, cp->text, lengthof(cp->text));
+	p->Recv_string(cp->text, lengthof(cp->text));
-	callback = NetworkRecv_uint8(cs, p);
+	callback = p->Recv_uint8();
 	if (cs->has_quit) return;
 	ci = DEREF_CLIENT_INFO(cs);
 	// This packets means a client noticed an error and is reporting this
 	//  to us. Display the error and report it to the other clients
 	NetworkTCPSocketHandler *new_cs;
 	char str[100];
 	char client_name[NETWORK_CLIENT_NAME_LENGTH];
-	NetworkErrorCode errorno = (NetworkErrorCode)NetworkRecv_uint8(cs, p);
+	NetworkErrorCode errorno = (NetworkErrorCode)p->Recv_uint8();
 	// The client was never joined.. thank the client for the packet, but ignore it
 	if (cs->status < STATUS_DONE_MAP || cs->has_quit) {
 		cs->has_quit = true;
 		return;
 	if (cs->status < STATUS_DONE_MAP || cs->has_quit) {
 		cs->has_quit = true;
 		return;
 	}
-	NetworkRecv_string(cs, p, str, lengthof(str));
+	p->Recv_string(str, lengthof(str));
 	NetworkGetClientName(client_name, sizeof(client_name), cs);
 	NetworkTextMessage(NETWORK_ACTION_LEAVE, 1, false, client_name, "%s", str);
 	cs->has_quit = true;
 }
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_ACK)
 {
-	uint32 frame = NetworkRecv_uint32(cs, p);
+	uint32 frame = p->Recv_uint32();
 	/* The client is trying to catch up with the server */
 	if (cs->status == STATUS_PRE_ACTIVE) {
 		/* The client is not yet catched up? */
 		if (frame + DAY_TICKS < _frame_counter) return;
 	}
 }
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_CHAT)
 {
-	NetworkAction action = (NetworkAction)NetworkRecv_uint8(cs, p);
+	NetworkAction action = (NetworkAction)p->Recv_uint8();
-	DestType desttype = (DestType)NetworkRecv_uint8(cs, p);
+	DestType desttype = (DestType)p->Recv_uint8();
-	int dest = NetworkRecv_uint8(cs, p);
+	int dest = p->Recv_uint8();
 	char msg[MAX_TEXT_MSG_LEN];
-	NetworkRecv_string(cs, p, msg, MAX_TEXT_MSG_LEN);
+	p->Recv_string(msg, MAX_TEXT_MSG_LEN);
 	NetworkServer_HandleChat(action, desttype, dest, msg, cs->index);
 }
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_SET_PASSWORD)
 {
 	char password[NETWORK_PASSWORD_LENGTH];
 	const NetworkClientInfo *ci;
-	NetworkRecv_string(cs, p, password, sizeof(password));
+	p->Recv_string(password, sizeof(password));
 	ci = DEREF_CLIENT_INFO(cs);
 	if (IsValidPlayer(ci->client_playas)) {
 		ttd_strlcpy(_network_player_info[ci->client_playas].password, password, sizeof(_network_player_info[0].password));
 	}
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_SET_NAME)
 {
 	char client_name[NETWORK_CLIENT_NAME_LENGTH];
 	NetworkClientInfo *ci;
-	NetworkRecv_string(cs, p, client_name, sizeof(client_name));
+	p->Recv_string(client_name, sizeof(client_name));
 	ci = DEREF_CLIENT_INFO(cs);
 	if (cs->has_quit) return;
 	if (ci != NULL) {
 	char pass[NETWORK_PASSWORD_LENGTH];
 	char command[NETWORK_RCONCOMMAND_LENGTH];
 	if (_network_game_info.rcon_password[0] == '\0') return;
-	NetworkRecv_string(cs, p, pass, sizeof(pass));
+	p->Recv_string(pass, sizeof(pass));
-	NetworkRecv_string(cs, p, command, sizeof(command));
+	p->Recv_string(command, sizeof(command));
 	if (strcmp(pass, _network_game_info.rcon_password) != 0) {
 		DEBUG(net, 0, "[rcon] wrong password from client-id %d", cs->index);
 		return;
 	}
 bool NetworkServer_ReadPackets(NetworkTCPSocketHandler *cs)
 {
 	Packet *p;
 	NetworkRecvStatus res;
 	while ((p = NetworkRecv_Packet(cs, &res)) != NULL) {
-		byte type = NetworkRecv_uint8(cs, p);
+		byte type = p->Recv_uint8();
 		if (type < PACKET_END && _network_server_packet[type] != NULL && !cs->has_quit) {
 			_network_server_packet[type](cs, p);
 		} else {
 			DEBUG(net, 0, "[server] received invalid packet type %d", type);
 		}

changeset 5900	135d10dd7219
parent 5898	4c682e9a58cc
child 5902	a9508c166390