#define FOR_EACH_SET_CARGO_ID(var, cargo_bits) FOR_EACH_SET_BIT_EX(CargoID, var, uint, cargo_bits)

#define FOR_ALL_SORTED_CARGOSPECS(var) for (uint8 index = 0; var = _sorted_cargo_specs[index], index < _sorted_cargo_specs_size; index++)

#define FOR_ALL_SORTED_STANDARD_CARGOSPECS(var) for (uint8 index = 0; var = _sorted_cargo_specs[index], index < _sorted_standard_cargo_specs_size; index++)

#endif /* CARGOTYPE_H */

#define BITMATH_FUNC_HPP

/**

 *

 * LSB, as this isn't just an and-bitmask but also some

 * bit-shifting operations. GB(0xFF, 2, 1) will so

 * return 0x01 (0000 0001) instead of

 * 0x04 (0000 0100).

 *

 * @param x The value to read some bits.

 * @param n The number of bits to read.

 * @return The selected bits, aligned to a LSB.

 */

 * This is not a bug, its a feature.

 *

 * @note Parameter \a x must be a variable as the result is saved there.

 *       space as the provided space of \a n bits (log2)

 * @param x The variable to change some bits

 * @param n The size/window for the new bits

 * @param d The actually new bits to save in the defined position.

 * @return The new value of \a x

}

/**

 *

 * saved there. An overflow does not affect the following bits of the given

 * bit window and is simply ignored.

 *

 * @note Parameter x must be a variable as the result is saved there.

 * @param x The variable to add some bits at some position

 * @param n The size/window for the addition

 */

template <typename T, typename U>

static inline T AB(T &x, const uint8 s, const uint8 n, const U i)

 * Checks if a bit in a value is set.

 *

 * This function checks if a bit inside a value is set or not.

 *

 * @param x The value to check

 * @param y The position of the bit to check, started from the LSB

 * changed and the value is also returned. Parameter y defines the bit

 * to toggle and starts at the LSB with 0.

 *

 * @param y The bit position to toggle

 * @return The new value of the old value with the bit toggled

 */

}

/**

 *

 * @note Assumes a byte has 8 bits

 * @param x The value which we want to rotate

 * @return A bit rotated number

 */

template <typename T>

}

/**

 *

 * @note Assumes a byte has 8 bits

 * @param x The value which we want to rotate

 * @return A bit rotated number

 */

template <typename T>

/**

 * Overflow safe template for integers, i.e. integers that will never overflow

 * the minimum value, etc.

 * @param T     the type these integers are stored with.

 * @param T_MAX the maximum value for the integers.

		return *this;

	}

	inline OverflowSafeInt  operator +  (const OverflowSafeInt& other) const { OverflowSafeInt result = *this; result += other; return result; }

	inline OverflowSafeInt  operator +  (const int              other) const { OverflowSafeInt result = *this; result += (int64)other; return result; }

	inline OverflowSafeInt  operator +  (const uint             other) const { OverflowSafeInt result = *this; result += (int64)other; return result; }

 * This function uses the same parameters as Chance16. The third parameter

 * must be a variable the randomize-number from Random() is saved in.

 *

 * Chance16I. One can only send the high 16 bits to Chance16I.

 *

 * @see Chance16I()

/**

 * Get the font loaded into a Freetype face by using a font-name.

 */

/* ========================================================================================

	}

}

/** Sort industry types by their name. */

static int CDECL IndustryTypeNameSorter(const IndustryType *a, const IndustryType *b)

	virtual void OnInvalidateData(int data = 0, bool gui_scope = true)

	{

		if (!gui_scope) return;

		InvalidateWindowData(WC_MAIN_TOOLBAR, 0, data, true);

	}

/**

 * An offset value between to tiles.

 *

 * to tiles. It can be added to a tileindex to get

 * the resulting tileindex of the start tile applied

 * with this saved difference.

	/*

	 * These first three pair of packets (thus six in

	 * total) must remain in this order for backward

	 * are trying to join directly.

	 */

void NetworkAfterNewGRFScan()

{

	for (NetworkGameList *item = _network_game_list; item != NULL; item = item->next) {

		item->info.compatible = item->info.version_compatible;

		for (GRFConfig *c = item->info.grfconfig; c != NULL; c = c->next) {

			if (f == NULL) {

				/* Don't know the GRF, so mark game incompatible and the (possibly)

				 * already resolved name for this GRF (another server has sent the

				c->name->Release();

				c->name = FindUnknownGRFName(c->ident.grfid, c->ident.md5sum, true);

				c->name->AddRef();

				c->status = GCS_NOT_FOUND;

				item->info.compatible = false;

			} else {

				c->filename = f->filename;

/**

 * Update the network new window because a new server is

 * found on the network.

 */

void UpdateNetworkGameWindow()

{

			this->server = this->servers[this->list_pos];

			this->ScrollToSelectedServer();

			/* redraw window */

	/* Only show once */

	if (first) {

		first = false;

		for (char **iter = _network_host_list.Begin(); iter != _network_host_list.End(); iter++) {

			NetworkAddServer(*iter);

		}

	{

		switch (widget) {

			case WID_NSS_SETPWD:

				if (!StrEmpty(_settings_client.network.server_password)) DrawString(r.right + WD_FRAMERECT_LEFT, this->width - WD_FRAMERECT_RIGHT, r.top, "*", TC_RED);

		}

	}

			case WID_NSS_CLIENTS_BTND:    case WID_NSS_CLIENTS_BTNU:    // Click on up/down button for number of clients

			case WID_NSS_COMPANIES_BTND:  case WID_NSS_COMPANIES_BTNU:  // Click on up/down button for number of companies

			case WID_NSS_SPECTATORS_BTND: case WID_NSS_SPECTATORS_BTNU: // Click on up/down button for number of spectators

				if (!(this->flags & WF_TIMEOUT) || this->timeout_timer <= 1) {

					this->HandleButtonClick(widget);

					this->SetDirty();

}

struct NetworkLobbyWindow : public Window {

	NetworkGameList *server; ///< Selected server

	NetworkCompanyInfo company_info[MAX_COMPANIES];

	Scrollbar *vscroll;

	CompanyID NetworkLobbyFindCompanyIndex(byte pos) const

	{

		for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) {

			if (!StrEmpty(this->company_info[i].company_name)) {

				if (pos-- == 0) return i;

	{

		const NetworkGameInfo *gi = &this->server->info;

		this->SetWidgetDisabledState(WID_NL_JOIN, this->company == INVALID_COMPANY || GetLobbyCompanyInfo(this->company)->ai);

		this->SetWidgetDisabledState(WID_NL_NEW, gi->companies_on >= gi->companies_max);

		this->SetWidgetDisabledState(WID_NL_SPECTATE, gi->spectators_on >= gi->spectators_max);

		this->vscroll->SetCount(gi->companies_on);

	void DrawDetails(const Rect &r) const

	{

		const int detail_height = 12 + FONT_HEIGHT_NORMAL + 12;

		GfxFillRect(r.left + 1, r.top + 1, r.right - 1, r.top + detail_height - 1, PC_DARK_BLUE);

		DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, r.top + 12, STR_NETWORK_GAME_LOBBY_COMPANY_INFO, TC_FROMSTRING, SA_HOR_CENTER);

			}

			case WID_NL_JOIN:     // Join company

				NetworkClientConnectGame(NetworkAddress(_settings_client.network.last_host, _settings_client.network.last_port), this->company);

				break;

		this->AddAction(STR_NETWORK_CLIENTLIST_SPEAK_TO_ALL, &ClientList_SpeakToAll);

		if (_network_own_client_id != ci->client_id) {

			if (Company::IsValidID(_local_company) && Company::IsValidID(ci->client_playas) && _settings_game.economy.give_money) {

				this->AddAction(STR_NETWORK_CLIENTLIST_GIVE_MONEY, &ClientList_GiveMoney);

			}

		}

		if (_network_server && _network_own_client_id != ci->client_id) {

			this->AddAction(STR_NETWORK_CLIENTLIST_KICK, &ClientList_Kick);

			this->AddAction(STR_NETWORK_CLIENTLIST_BAN, &ClientList_Ban);

				const GRFConfig *best = FindGRFConfig(c->ident.grfid, HasBit(c->flags, GCF_INVALID) ? FGCM_NEWEST : FGCM_NEWEST_VALID);

				/*

				 * If the best version is 0, then all NewGRF with this GRF ID

				 * want to show them all.

				 * If we are the best version, then we definitely want to

				 * show that NewGRF!.

 */

enum OrderLoadFlags {

	OLF_LOAD_IF_POSSIBLE = 0,      ///< Load as long as there is cargo that fits in the train.

	OLFB_NO_LOAD         = 4,      ///< Do not load anything.

};

/**

 */

enum ModifyOrderFlags {

	MOF_NON_STOP,        ///< Passes an OrderNonStopFlags.

template <> struct EnumPropsT<ModifyOrderFlags> : MakeEnumPropsT<ModifyOrderFlags, byte, MOF_NON_STOP, MOF_END, MOF_END, 4> {};

/**

 */

enum OrderDepotAction {

	DA_ALWAYS_GO, ///< Always go to the depot

};

/**

 */

enum ModifyTimetableFlags {

	MTF_WAIT_TIME,    ///< Set wait time.

template <> struct EnumPropsT<ModifyTimetableFlags> : MakeEnumPropsT<ModifyTimetableFlags, byte, MTF_WAIT_TIME, MTF_END, MTF_END, 2> {};

enum CloneOptions {

	CO_SHARE   = 0,

	CO_COPY    = 1,

	for (RoadStop *rs = this->next; rs != NULL; rs = rs->next) {

		/* The vehicle cannot go to this roadstop (different roadtype) */

		if ((GetRoadTypes(rs->xy) & v->compatible_roadtypes) == ROADTYPES_NONE) continue;

		if (IsStandardRoadStopTile(rs->xy) && v->HasArticulatedPart()) continue;

		/* The vehicle can actually go to this road stop. So, return it! */

	SetDate(_date, _date_fract);

	/*

	 *

	 * Note that there is no non-stop in here. This is because the setting could have

	 * either value in TTDPatch. To convert it properly the user has to make sure the

/**

 * Pointers cannot be loaded from a savegame, so this function

 * pointer from the already loaded base.

 * Remember that an index of 0 is a NULL pointer so all indices

 * are +1 so vehicle 0 is saved as 1.

/**

 * Save a chunk of data (eg. vehicles, stations, etc.). Each chunk is

 * @param ch The chunkhandler that will be used for the operation

 */

static void SlSaveChunk(const ChunkHandler *ch)

 * Find the ChunkHandler that will be used for processing the found

 * chunk in the savegame or in memory

 * @param id the chunk in question

 */

static const ChunkHandler *SlFindChunkHandler(uint32 id)

{

/**

 * We have written the whole game into memory, _memory_savegame, now find

 */

static SaveOrLoadResult SaveFileToDisk(bool threaded)

{

	/**

	 * Move a vehicle to a group.

	 * @param vehicle_id The vehicle to move to the group.

	 * @pre IsValidGroup(group_id) || group_id == GROUP_DEFAULT.

	 * @pre ScriptVehicle::IsValidVehicle(vehicle_id).

	 *  (auto)replaced with a longer variant (longer wagons or longer engines)

	 *  If enabled, wagons are removed from the end of the vehicle until it

	 *  fits in the same number of tiles as it did before.

	 * @return True if and only if the value was successfully changed.

	 */

	static bool EnableWagonRemoval(bool keep_length);

	 * Can a non-developer select Script for a new game.

	 *

	 * The idea behind this function is to 'forbid' using your script with a new

	 *

	 * @return True if the Script can be selected from the GUI as non-developer.

	 * @note This function is optional. Default is false.

	/**

	 * Gets the API version this Script is written for. If this function

	 * If the function returns something OpenTTD does not understand,

	 * for example a newer version or a string that is not a version,

	 * the Script will not be loaded.

	 *

	 * Although in the future we might need to make a separate

	 * example '0.7.1', we will use only the major and minor number

	 * and not the bugfix number as valid return for this function.

	 *

	 * @param setting_name The name of the setting.

	 * @param value_names A table that maps values to names. The first

	 *   character of every identifier is ignored and the rest should

	 *   is a short description of that value.

	 * To define labels for a setting named "competition_level" you could

	 * for example call it like this:

/* The reason this exists in C++, is that a user can trash his ai/ or game/ dir,

 *  leaving no Scripts available. The complexity to solve this is insane, and

 *  available, no matter what the situation is. By defining it in C++, there

 *  to be noted that this Script is complete invisible for the user, and impossible

 *  to select manual. It is a fail-over in case no Scripts are available.

 */

 *  |    |-- setting

 * \endverbatim

 * The left-most vertical line is not wanted. It is prevented by setting the

 *

 * @param settings_ptr Pointer to current values of all settings

 * @param left         Left-most position in window/panel to start drawing \a first_row

	for (; rs != NULL; rs = rs->next) {

		/* The vehicle cannot go to this roadstop (different roadtype) */

		if ((GetRoadTypes(rs->xy) & v->compatible_roadtypes) == ROADTYPES_NONE) continue;

		if (IsStandardRoadStopTile(rs->xy) && v->HasArticulatedPart()) continue;

		/* The vehicle can actually go to this road stop. So, return it! */

 * One interpolation and noise round

 *

 * The heights on the map are generated in an iterative process.

 * (i.e. only for x/y coordinates which are multiples of the minimum edge length).

 *

 * After this initial step the frequency is doubled (log_frequency incremented) each iteration to generate corners on the next finer mesh.

			return true;

		}

	}

	return false;

}