/* Don't kill the server, or the client doing the rcon. The latter can't be kicked because

		 * kicking frees closes and subsequently free the connection related instances, which we

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

		}

		NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id);

		if (ci == nullptr) {

			IConsoleError("Invalid client");

DEF_CONSOLE_CMD(ConBan)

{

	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 (argc != 2 && argc != 3) return false;

	/* No reason supplied for kicking */

	if (company_id != COMPANY_SPECTATOR && !Company::IsHumanID(company_id)) {

		IConsoleError("You cannot move clients to AI companies.");

		return true;

	}

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

		return true;

	}

	if (ci->client_playas == company_id) {

		return true;

	}

	/* we are the server, so force the update */

	NetworkServerDoMove(ci->client_id, company_id);

		 * after 9 months (if it still had value after 6 months) */

		default:

		case 10: {

			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;

			}

			/* Actually remove the company, but not when we're a network client.

	}

}

/**

 * Compute who can service the industry.

 *

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

 * technical means).

 *

 * @param ind: Industry being investigated.

 *

 * @return: 0 if nobody can service the industry, 2 if the local company can

/**

 * Handle an error coming from the client side.

 * @param res The "error" that happened.

 */

void ClientNetworkGameSocketHandler::ClientError(NetworkRecvStatus res)

{

	NetworkErrorCode errorno;

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

	if (res == NETWORK_RECV_STATUS_CLOSE_QUERY) {

		this->NetworkSocketHandler::CloseConnection();

		this->CloseConnection(res);

				my_client->ClientError(NETWORK_RECV_STATUS_DESYNC);

				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

			if (_network_first_time) {

				_network_first_time = false;

				SendAck();

			}

			_sync_frame = 0;

void NetworkClientSetCompanyPassword(const char *password)

{

	MyClient::SendSetPassword(password);

}

/**

 * @param cio client to check members of.

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

 */

bool NetworkClientPreferTeamChat(const NetworkClientInfo *cio)

{

	/* Only companies actually playing can speak to team. Eg spectators cannot */

		this->GetClientName(client_name, lastof(client_name));

		NetworkTextMessage(NETWORK_ACTION_JOIN, CC_DEFAULT, false, client_name, nullptr, this->client_id);

		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();

		this->SendSync();

		/* This is the frame the client receives

	/* The client is trying to catch up with the server */

	if (this->status == STATUS_PRE_ACTIVE) {

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

		/* Execute script for, e.g. MOTD */

		IConsoleCmdExec("exec scripts/on_server_connect.scr 0");

	}

					continue;

				}

				break;

			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();

				}

				break;

			case NetworkClientSocket::STATUS_MAP:

	uint32 last_token_frame;     ///< The last frame we received the right token

	ClientStatus status;         ///< Status of this client

	CommandQueue outgoing_queue; ///< The command-queue awaiting delivery

	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();

	virtual Packet *ReceivePacket() override;

	NetworkRecvStatus CloseConnection(NetworkRecvStatus status) override;

			break;

		}

		if (i == -2) break;

	}

	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

		 * because then we cannot show it on the debug console as that hasn't been configured yet. */

		DeterminePaths(argv[0]);

		TarScanner::DoScan(TarScanner::BASESET);

}

/**

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

{

	DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_TOO_FEW_ORDERS);

	DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_VOID_ORDER);

	DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_DUPLICATE_ENTRY);

					 * for 'big' corners. It furthermore does not go to the next tile,

					 * so that needs to be fixed too.

					 */

					tile = v->tile;

					start_frame = RVC_TURN_AROUND_START_FRAME_SHORT_TRAM;

				} else {

					v->cur_speed = 0;

					return false;

				}

			} else if (IsNormalRoadTile(v->tile) && GetDisallowedRoadDirections(v->tile) != DRD_NONE) {

				v->cur_speed = 0;

				return false;

						DEBUG(script, 0, "A random available AI will be loaded now.");

					}

				} else {

					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;

			}

		}

		config->StringToSettings(_ai_saveload_settings);

					DEBUG(script, 0, "This game will continue to run without GameScript.");

				}

			} else {

				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;

		}

	}

	config->StringToSettings(_game_saveload_settings);

	 * has been closing, up to the point we would start to reuse versions from

	 * their patchpacks. This is not a problem from our perspective: the

	 * savegame will simply fail to load because they all contain chunks we

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

	 */

	SLV_START_PATCHPACKS,                   ///< 220  First known patchpack to use a version just above ours.

	SLV_END_PATCHPACKS = 286,               ///< 286  Last known patchpack to use a version just above ours.

public:

	/**

	 * 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);

	/**

	 * Destroying this instance reset the company to that what it was

	 */

	ScriptGoal::QuestionButton GetButton() { return this->button; }

private:

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

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

};

/**

 * Base class for events involving a town and a company.

 * @api ai game

 */

	 */

	static bool ModeProc();

public:

	/**

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

	 *   current when the instance was created!

	 */

	ScriptExecMode();

	/**

	 * Destroying this instance reset the building mode to the mode it was

 * @api ai game

 * @ingroup ScriptList

 */

class ScriptStationList_Vehicle : public ScriptList {

public:

	/**

	 */

	ScriptStationList_Vehicle(VehicleID vehicle_id);

};

#endif /* SCRIPT_STATIONLIST_HPP */

	 */

	static bool ModeProc();

public:

	/**

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

	 *   current when the instance was created!

	 */

	ScriptTestMode();

	/**

	 * Destroying this instance reset the building mode to the mode it was

		using namespace SQConvert;

		engine->AddMethod(function_name, DefSQAdvancedNonStaticCallback<CL, Func, ST>, 0, nullptr, &function_proc, sizeof(function_proc));

	}

	/**

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

	 */

	template <typename Func>

	void DefSQMethod(Squirrel *engine, Func function_proc, const char *function_name, int nparam, const char *params)

	{

		using namespace SQConvert;

		engine->AddMethod(function_name, DefSQAdvancedStaticCallback<CL, Func>, 0, nullptr, &function_proc, sizeof(function_proc));

	}

	/**

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

	 */

	template <typename Func>

	void DefSQStaticMethod(Squirrel *engine, Func function_proc, const char *function_name, int nparam, const char *params)

	{

		/* Build a new house, but add a small delay to make sure

		 * that spamming funding doesn't let town grow any faster

		 * 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);

		SetWindowDirty(WC_TOWN_VIEW, t->index);

	}