DEBUG(net, 0)("[NET] Sync error detected!");

				NetworkClientError(NETWORK_RECV_STATUS_DESYNC, DEREF_CLIENT(0));

				return false;

			}

			// If this is the first time we have a sync-frame, we

			//   need to let the server know that we are ready and at the same

			//   frame as he is.. so we can start playing!

			if (_network_first_time) {

				_network_first_time = false;

				SEND_COMMAND(PACKET_CLIENT_ACK)();

			}

			_sync_frame = 0;

		} else if (_sync_frame < _frame_counter) {

			DEBUG(net, 1)("[NET] Missed frame for sync-test (%d / %d)", _sync_frame, _frame_counter);

			_sync_frame = 0;

		}

	}

	return true;

}

// We have to do some UDP checking

void NetworkUDPGameLoop(void)

{

	if (_network_udp_server) {

		NetworkUDPReceive(_udp_server_socket);

		if (_udp_master_socket != INVALID_SOCKET) {

			NetworkUDPReceive(_udp_master_socket);

		}

	}

	else if (_udp_client_socket != INVALID_SOCKET) {

		NetworkUDPReceive(_udp_client_socket);

		if (_network_udp_broadcast > 0)

			_network_udp_broadcast--;

	}

}

// The main loop called from ttd.c

//  Here we also have to do StateGameLoop if needed!

void NetworkGameLoop(void)

{

	if (!_networking) return;

	if (!NetworkReceive()) return;

	if (_network_server) {

		// We first increase the _frame_counter

		_frame_counter++;

		NetworkHandleLocalQueue();

		// Then we make the frame

		StateGameLoop();

		_sync_seed_1 = _random_seeds[0][0];

#ifdef NETWORK_SEND_DOUBLE_SEED

		_sync_seed_2 = _random_seeds[0][1];

#endif

	} else {

		// Client

		// Make sure we are at the frame were the server is (quick-frames)

		if (_frame_counter_server > _frame_counter) {

			while (_frame_counter_server > _frame_counter) {

				if (!NetworkDoClientLoop()) break;

			}

		} else {

			// Else, keep on going till _frame_counter_max

			if (_frame_counter_max > _frame_counter) {

				NetworkDoClientLoop();

			}

		}

	}

	NetworkSend();

}

static void NetworkGenerateUniqueId(void)

{

	md5_state_t state;

	md5_byte_t digest[16];

	char hex_output[16*2 + 1];

	char coding_string[NETWORK_NAME_LENGTH];

	int di;

	snprintf(coding_string, sizeof(coding_string), "%d%s", (uint)Random(), "OpenTTD Unique ID");

	/* Generate the MD5 hash */

	md5_init(&state);

	md5_append(&state, coding_string, strlen(coding_string));

	md5_finish(&state, digest);

	for (di = 0; di < 16; ++di)

		sprintf(hex_output + di * 2, "%02x", digest[di]);

	/* _network_unique_id is our id */

	snprintf(_network_unique_id, sizeof(_network_unique_id), "%s", hex_output);

}

// This tries to launch the network for a given OS

void NetworkStartUp(void)

{

	DEBUG(net, 3) ("[NET][Core] Starting network...");

	#if defined(__MORPHOS__) || defined(__AMIGA__)

	/*

			if (strncmp(ci->client_name, new_name, NETWORK_CLIENT_NAME_LENGTH) == 0) {

				// Name already in use

				found_name = false;

			}

		}

		if (!found_name) {

			// Try a new name (<name> #1, <name> #2, and so on)

			// Stop if we tried for more than 50 times..

			if (number++ > 50) break;

			snprintf(new_name, NETWORK_CLIENT_NAME_LENGTH, "%s #%d", original_name, number);

		}

	}

	return found_name;

}

// Reads a packet from the stream

bool NetworkServer_ReadPackets(NetworkClientState *cs)

{

	Packet *p;

	NetworkRecvStatus res;

	while((p = NetworkRecv_Packet(cs, &res)) != NULL) {

		byte type = NetworkRecv_uint8(cs, p);

		if (type < PACKET_END && _network_server_packet[type] != NULL && !cs->quited)

			_network_server_packet[type](cs, p);

		else

			DEBUG(net, 0)("[NET][Server] Received invalid packet type %d", type);

		free(p);

	}

	return true;

}

// Handle the local command-queue

void NetworkHandleCommandQueue(NetworkClientState *cs) {

	CommandPacket *cp;

	while ( (cp = cs->command_queue) != NULL) {

		SEND_COMMAND(PACKET_SERVER_COMMAND)(cs, cp);

		cs->command_queue = cp->next;

		free(cp);

	}

}

// This is called every tick if this is a _network_server

{

	NetworkClientState *cs;

#ifndef ENABLE_NETWORK_SYNC_EVERY_FRAME

	bool send_sync = false;

#endif

#ifndef ENABLE_NETWORK_SYNC_EVERY_FRAME

	if (_frame_counter >= _last_sync_frame + _network_sync_freq) {

		_last_sync_frame = _frame_counter;

		send_sync = true;

	}

#endif

	// Now we are done with the frame, inform the clients that they can

	//  do their frame!

	FOR_ALL_CLIENTS(cs) {

		// Check if the speed of the client is what we can expect from a client

		if (cs->status == STATUS_ACTIVE) {

			// 1 lag-point per day

			int lag = NetworkCalculateLag(cs) / DAY_TICKS;

			if (lag > 0) {

				if (lag > 3) {

					// Client did still not report in after 4 game-day, drop him

					//  (that is, the 3 of above, + 1 before any lag is counted)

					IConsolePrintF(_icolour_err,"Client #%d is dropped because the client did not respond for more than 4 game-days", cs->index);

					NetworkCloseClient(cs);

					continue;

				}

				// Report once per time we detect the lag

				if (cs->lag_test == 0) {

					IConsolePrintF(_icolour_warn,"[%d] Client #%d is slow, try increasing *net_frame_freq to a higher value!", _frame_counter, cs->index);

					cs->lag_test = 1;

				}

			} else {

				cs->lag_test = 0;

			}

		} else if (cs->status == STATUS_PRE_ACTIVE) {

			int lag = NetworkCalculateLag(cs);

			if (lag > _network_max_join_time) {

				IConsolePrintF(_icolour_err,"Client #%d is dropped because it took longer than %d ticks for him to join", cs->index, _network_max_join_time);

				NetworkCloseClient(cs);

			}

		}

		if (cs->status >= STATUS_PRE_ACTIVE) {

			// Check if we can send command, and if we have anything in the queue

			NetworkHandleCommandQueue(cs);

			// Send an updated _frame_counter_max to the client

			if (send_frame)

				SEND_COMMAND(PACKET_SERVER_FRAME)(cs);

#ifndef ENABLE_NETWORK_SYNC_EVERY_FRAME

/* $Id$ */

#ifndef NETWORK_SERVER_H

#define NETWORK_SERVER_H

#ifdef ENABLE_NETWORK

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP);

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR_QUIT)(NetworkClientState *cs, uint16 client_index, NetworkErrorCode errorno);

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR)(NetworkClientState *cs, NetworkErrorCode error);

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SHUTDOWN);

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_NEWGAME);

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_RCON)(NetworkClientState *cs, uint16 color, const char *command);

bool NetworkFindName(char new_name[NETWORK_NAME_LENGTH]);

void NetworkServer_HandleChat(NetworkAction action, DestType desttype, int dest, const char *msg, uint16 from_index);

bool NetworkServer_ReadPackets(NetworkClientState *cs);

void NetworkServerMonthlyLoop(void);

void NetworkServerYearlyLoop(void);

#endif /* ENABLE_NETWORK */

#endif // NETWORK_SERVER_H