* would be reading from and writing to after returning. So we would read or write data

		 * from freed memory up till the segfault triggers. */

		if (client_id == CLIENT_ID_SERVER || client_id == _redirect_console_to_client) {

			return true;

		}

	if (argc == 0) {

		IConsoleHelp("Ban a client from a network game. Usage: 'ban <ip | client-id> [<ban-reason>]'");

		IConsoleHelp("For client-id's, see the command 'clients'");

		return true;

	}

	}

	if (ci->client_id == CLIENT_ID_SERVER && _network_dedicated) {

		return true;

	}

	if (ci->client_playas == company_id) {

		return true;

	}

			if (!_networking && _local_company == c->index) {

				/* If we are in singleplayer mode, leave the company playing. Eg. there

				 * is no THE-END, otherwise mark the client as spectator to make sure

				 * join another company (cheat) the "unowned" company can bankrupt. */

				c->bankrupt_asked = MAX_UVALUE(CompanyMask);

				break;

/**

 * Compute who can service the industry.

 *

 * to the industry with the right cargo type and the right orders (ie has the

 * technical means).

 *

 */

void ClientNetworkGameSocketHandler::ClientError(NetworkRecvStatus res)

{

	NetworkErrorCode errorno;

	/* We just want to close the connection.. */

			/* 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

			if (_network_first_time) {

				_network_first_time = false;

				SendAck();

}

/**

 * @param cio client to check members of.

 * @return true if there is at least one team member.

 */

		InvalidateWindowData(WC_CLIENT_LIST, 0);

		/* Mark the client as pre-active, and wait for an ACK

		this->status = STATUS_PRE_ACTIVE;

		NetworkHandleCommandQueue(this);

		this->SendFrame();

		/* The client is not yet caught up? */

		if (frame + DAY_TICKS < _frame_counter) return NETWORK_RECV_STATUS_OKAY;

		this->status = STATUS_ACTIVE;

		this->last_token_frame = _frame_counter;

			case NetworkClientSocket::STATUS_MAP_WAIT:

				/* Send every two seconds a packet to the client, to make sure

				 * still receiving the map. */

				if (std::chrono::steady_clock::now() > cs->last_packet + std::chrono::seconds(2)) {

					cs->SendWait();

					/* We need to reset the timer, as otherwise we will be

					 * spamming the client. Strictly speaking this variable

					 * tracks when we last received a packet from the client,

					 * start sending him data. */

					cs->last_packet = std::chrono::steady_clock::now();

				}

	size_t receive_limit;        ///< Amount of bytes that we can receive at this moment

	struct PacketWriter *savegame; ///< Writer used to write the savegame.

	ServerNetworkGameSocketHandler(SOCKET s);

	~ServerNetworkGameSocketHandler();

	}

	if (i == -2 || mgo.numleft > 0) {

		 * In all cases, print the help, and exit.

		 *

		 * The next two functions are needed to list the graphics sets. We can't do them earlier

 * Delete all news items regarding defective orders about a vehicle

 * This could kill still valid warnings (for example about void order when just

 * another order gets added), but assume the company will notice the problems,

 */

static void DeleteOrderWarnings(const Vehicle *v)

{

					tile = v->tile;

					start_frame = RVC_TURN_AROUND_START_FRAME_SHORT_TRAM;

				} else {

					v->cur_speed = 0;

					return false;

				}

					DEBUG(script, 0, "The savegame has an AI by the name '%s', version %d which is no longer available.", _ai_saveload_name, _ai_saveload_version);

					DEBUG(script, 0, "The latest version of that AI has been loaded instead, but it'll not get the savegame data as it's incompatible.");

				}

				 *  writer of the saveload data in the first place */

				_ai_saveload_version = -1;

			}

				DEBUG(script, 0, "The savegame has an GameScript by the name '%s', version %d which is no longer available.", _game_saveload_name, _game_saveload_version);

				DEBUG(script, 0, "The latest version of that GameScript has been loaded instead, but it'll not get the savegame data as it's incompatible.");

			}

			 *  writer of the saveload data in the first place */

			_game_saveload_version = -1;

		}

	 * cannot digest. But, this gives for ugly errors. As we have plenty of

	 * versions anyway, we simply skip the versions we know belong to

	 * patchpacks. This way we can present the user with a clean error

	 * For future patchpack creators: please follow a system like JGRPP, where

	 * the version is masked with 0x8000, and the true version is stored in

	 * its own chunk with feature toggles.

	 * Creating instance of this class switches the company used for queries

	 *  and commands.

	 * @param company The new company to switch to.

	 *   current when the instance was created!

	 */

	ScriptCompanyMode(int company);

private:

	uint16 uniqueid;                   ///< The uniqueid of the question.

	ScriptCompany::CompanyID company;  ///< The company given the answer.

};

/**

public:

	/**

	 * Creating instance of this class switches the build mode to Execute.

	 *   current when the instance was created!

	 */

	ScriptExecMode();

class ScriptStationList_Vehicle : public ScriptList {

public:

	/**

	 */

	ScriptStationList_Vehicle(VehicleID vehicle_id);

};

public:

	/**

	 * Creating instance of this class switches the build mode to Testing.

	 *   current when the instance was created!

	 */

	ScriptTestMode();

	/**

	 * This defines a method inside a class for Squirrel with defined params.

	 *  which is the 'this' inside the function. This is hidden from the rest

	 *  of the code, but without it calling your function will fail!

	 */

	/**

	 * This defines a static method inside a class for Squirrel with defined params.

	 *  which is the 'this' inside the function. This is hidden from the rest

	 *  of the code, but without it calling your function will fail!

	 */

		 * than 1 house per 2 * TOWN_GROWTH_TICKS ticks.

		 * Also emulate original behaviour when town was only growing in

		 * TOWN_GROWTH_TICKS intervals, to make sure that it's not too

		 * spam funding with the exact same efficiency.

		 */

		t->grow_counter = std::min<uint16>(t->grow_counter, 2 * TOWN_GROWTH_TICKS - (t->growth_rate - t->grow_counter) % TOWN_GROWTH_TICKS);