STR_SPRITE_ALIGNER_GOTO_CAPTION                                 :{WHITE}Go to sprite

# NewGRF (self) generated warnings/errors

STR_NEWGRF_ERROR_MSG_INFO                                       :{SILVER}{RAW_STRING}

STR_NEWGRF_ERROR_MSG_WARNING                                    :{RED}Warning: {SILVER}{RAW_STRING}

STR_NEWGRF_ERROR_MSG_ERROR                                      :{RED}Error: {SILVER}{RAW_STRING}

STR_NEWGRF_ERROR_MSG_FATAL                                      :{RED}Fatal: {SILVER}{RAW_STRING}

STR_NEWGRF_ERROR_FATAL_POPUP                                    :{WHITE}A fatal NewGRF error has occurred: {}{STRING5}

STR_NEWGRF_ERROR_VERSION_NUMBER                                 :{1:STRING1} will not work with the TTDPatch version reported by OpenTTD.

STR_NEWGRF_ERROR_DOS_OR_WINDOWS                                 :{1:STRING1} is for the {STRING1} version of TTD.

STR_NEWGRF_ERROR_UNSET_SWITCH                                   :{1:STRING1} is designed to be used with {STRING1}

STR_NEWGRF_ERROR_INVALID_PARAMETER                              :Invalid parameter for {1:STRING1}: parameter {STRING1} ({NUM})

STR_NEWGRF_ERROR_LOAD_BEFORE                                    :{1:STRING1} must be loaded before {STRING1}.

STR_NEWGRF_ERROR_LOAD_AFTER                                     :{1:STRING1} must be loaded after {STRING1}.

STR_NEWGRF_ERROR_OTTD_VERSION_NUMBER                            :{1:STRING1} requires OpenTTD version {STRING1} or better.

STR_NEWGRF_ERROR_AFTER_TRANSLATED_FILE                          :the GRF file it was designed to translate

STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED                        :Too many NewGRFs are loaded.

STR_NEWGRF_ERROR_STATIC_GRF_CAUSES_DESYNC                       :Loading {RAW_STRING} as static NewGRF with {RAW_STRING} could cause desyncs.

STR_NEWGRF_ERROR_UNEXPECTED_SPRITE                              :Unexpected sprite.

STR_NEWGRF_ERROR_UNKNOWN_PROPERTY                               :Unknown Action 0 property.

STR_NEWGRF_ERROR_INVALID_ID                                     :Attempt to use invalid ID.

STR_NEWGRF_ERROR_CORRUPT_SPRITE                                 :{YELLOW}{RAW_STRING} contains a corrupt sprite. All corrupt sprites will be shown as a red question mark (?).

STR_NEWGRF_ERROR_MULTIPLE_ACTION_8                              :Contains multiple Action 8 entries.

STR_NEWGRF_ERROR_READ_BOUNDS                                    :Read past end of pseudo-sprite.

# NewGRF related 'general' warnings

STR_NEWGRF_POPUP_CAUTION_CAPTION                                :{WHITE}Caution!

STR_NEWGRF_CONFIRMATION_TEXT                                    :{YELLOW}You are about to make changes to a running game. This can crash OpenTTD.{}Are you absolutely sure about this?

STR_NEWGRF_DUPLICATE_GRFID                                      :{WHITE}Can't add file: duplicate GRF ID

STR_NEWGRF_COMPATIBLE_LOADED                                    :{ORANGE}Matching file not found (compatible GRF loaded)

STR_NEWGRF_COMPATIBLE_LOAD_WARNING                              :{WHITE}Compatible GRF(s) loaded for missing files

STR_NEWGRF_DISABLED_WARNING                                     :{WHITE}Missing GRF file(s) have been disabled

STR_NEWGRF_UNPAUSE_WARNING_TITLE                                :{YELLOW}Missing GRF file(s)

STR_NEWGRF_UNPAUSE_WARNING                                      :{WHITE}Unpausing can crash OpenTTD. Do not file bug reports for subsequent crashes.{}Do you really want to unpause?

# NewGRF status

STR_NEWGRF_LIST_NONE                                            :None

STR_NEWGRF_LIST_ALL_FOUND                                       :All files present

STR_NEWGRF_LIST_COMPATIBLE                                      :{YELLOW}Found compatible files

STR_NEWGRF_LIST_MISSING                                         :{RED}Missing files

# NewGRF 'it's broken' warnings

STR_NEWGRF_BROKEN                                               :{WHITE}Behaviour of NewGRF '{0:RAW_STRING}' is likely to cause desyncs and/or crashes.

STR_NEWGRF_BROKEN_POWERED_WAGON                                 :{WHITE}It changed powered-wagon state for '{1:ENGINE}' when not inside a depot.

STR_NEWGRF_BROKEN_VEHICLE_LENGTH                                :{WHITE}It changed vehicle length for '{1:ENGINE}' when not inside a depot.

STR_BROKEN_VEHICLE_LENGTH                                       :{WHITE}Train '{VEHICLE}' belonging to '{COMPANY}' has invalid length. It is probably caused by problems with NewGRFs. Game may desync or crash.

#include "newgrf.h"

#include "newgrf_cargo.h"

#include "newgrf_house.h"

#include "newgrf_sound.h"

#include "newgrf_station.h"

#include "industry.h"

#include "newgrf_canal.h"

#include "newgrf_commons.h"

#include "newgrf_townname.h"

#include "newgrf_industries.h"

#include "newgrf_airporttiles.h"

#include "newgrf_airport.h"

#include "rev.h"

#include "fios.h"

#include "rail.h"

#include "strings_func.h"

#include "date_func.h"

#include "string_func.h"

#include "network/network.h"

#include <map>

#include "core/alloc_type.hpp"

#include "core/mem_func.hpp"

#include "smallmap_gui.h"

#include "genworld.h"

#include "table/strings.h"

#include "table/build_industry.h"

/* TTDPatch extended GRF format codec

 * (c) Petr Baudis 2004 (GPL'd)

 * Changes by Florian octo Forster are (c) by the OpenTTD development team.

 *

 * Contains portions of documentation by TTDPatch team.

 * Thanks especially to Josef Drexler for the documentation as well as a lot

 * of help at #tycoon. Also thanks to Michael Blunck for is GRF files which

 * served as subject to the initial testing of this codec. */

static int _skip_sprites; // XXX

static uint _file_index; // XXX

static SmallVector<GRFFile *, 16> _grf_files;

static GRFFile *_cur_grffile;

static SpriteID _cur_spriteid;

static GrfLoadingStage _cur_stage;

static uint32 _nfo_line;

 * @param max_sprites the maximum number of sprites that can be loaded in this action 5.

 * @param name        used for error warnings.

 * @return the number of sprites that is going to be skipped

 */

static uint16 SanitizeSpriteOffset(uint16& num, uint16 offset, int max_sprites, const char *name)

{

	if (offset >= max_sprites) {

		grfmsg(1, "GraphicsNew: %s sprite offset must be less than %i, skipping", name, max_sprites);

		uint orig_num = num;

		num = 0;

		return orig_num;

	}

	if (offset + num > max_sprites) {

		grfmsg(4, "GraphicsNew: %s sprite overflow, truncating...", name);

		uint orig_num = num;

		num = max(max_sprites - offset, 0);

		return orig_num - num;

	}

	return 0;

}

/* Action 0x05 */

static void GraphicsNew(ByteReader *buf)

{

	/* <05> <graphics-type> <num-sprites> <other data...>

	 *

	 * B graphics-type What set of graphics the sprites define.

	 * E num-sprites   How many sprites are in this set?

	 * V other data    Graphics type specific data.  Currently unused. */

	/* TODO */

	uint8 type = buf->ReadByte();

	uint16 num = buf->ReadExtendedByte();

	uint16 offset = HasBit(type, 7) ? buf->ReadExtendedByte() : 0;

	ClrBit(type, 7); // Clear the high bit as that only indicates whether there is an offset.

	if ((type == 0x0D) && (num == 10) && _cur_grffile->is_ottdfile) {

		 * Missing shore sprites and initialisation of SPR_SHORE_BASE */

		LoadNextSprite(SPR_SHORE_BASE +  0, _file_index, _nfo_line++); // SLOPE_STEEP_S

		LoadNextSprite(SPR_SHORE_BASE +  5, _file_index, _nfo_line++); // SLOPE_STEEP_W

		LoadNextSprite(SPR_SHORE_BASE +  7, _file_index, _nfo_line++); // SLOPE_WSE

		LoadNextSprite(SPR_SHORE_BASE + 10, _file_index, _nfo_line++); // SLOPE_STEEP_N

		LoadNextSprite(SPR_SHORE_BASE + 11, _file_index, _nfo_line++); // SLOPE_NWS

		LoadNextSprite(SPR_SHORE_BASE + 13, _file_index, _nfo_line++); // SLOPE_ENW

		LoadNextSprite(SPR_SHORE_BASE + 14, _file_index, _nfo_line++); // SLOPE_SEN

		LoadNextSprite(SPR_SHORE_BASE + 15, _file_index, _nfo_line++); // SLOPE_STEEP_E

		LoadNextSprite(SPR_SHORE_BASE + 16, _file_index, _nfo_line++); // SLOPE_EW

		LoadNextSprite(SPR_SHORE_BASE + 17, _file_index, _nfo_line++); // SLOPE_NS

		if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ONLY_NEW;

		return;

	}

	/* Supported type? */

		grfmsg(2, "GraphicsNew: Custom graphics (type 0x%02X) sprite block of length %u (unimplemented, ignoring)", type, num);

		_skip_sprites = num;

		return;

	}

	/* Ignore offset if not allowed */

	if ((action5_type->block_type != A5BLOCK_ALLOW_OFFSET) && (offset != 0)) {

		grfmsg(1, "GraphicsNew: %s (type 0x%02X) do not allow an <offset> field. Ignoring offset.", action5_type->name, type);

		offset = 0;

	}

	/* Ignore action5 if too few sprites are specified. (for TTDP compatibility)

	 * This does not make sense, if <offset> is allowed */

	if ((action5_type->block_type == A5BLOCK_FIXED) && (num < action5_type->min_sprites)) {

		grfmsg(1, "GraphicsNew: %s (type 0x%02X) count must be at least %d. Only %d were specified. Skipping.", action5_type->name, type, action5_type->min_sprites, num);

		_skip_sprites = num;

		return;

	}

	/* Load at most max_sprites sprites. Skip remaining sprites. (for compatibility with TTDP and future extentions) */

	uint16 skip_num = SanitizeSpriteOffset(num, offset, action5_type->max_sprites, action5_type->name);

	SpriteID replace = action5_type->sprite_base + offset;

	/* Load <num> sprites starting from <replace>, then skip <skip_num> sprites. */

	grfmsg(2, "GraphicsNew: Replacing sprites %d to %d of %s (type 0x%02X) at SpriteID 0x%04X", offset, offset + num - 1, action5_type->name, type, replace);

	for (; num > 0; num--) {

		_nfo_line++;

		LoadNextSprite(replace == 0 ? _cur_spriteid++ : replace++, _file_index, _nfo_line);

	}

	if (type == 0x0D) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_5;

	_skip_sprites = skip_num;

}

/* Action 0x05 (SKIP) */

static void SkipAct5(ByteReader *buf)

{

	/* Ignore type byte */

	buf->ReadByte();

	/* Skip the sprites of this action */

	_skip_sprites = buf->ReadExtendedByte();

	grfmsg(3, "SkipAct5: Skipping %d sprites", _skip_sprites);

}

/**

 * Reads a variable common to VarAction2 and Action7/9/D.

 *

 * Returns VarAction2 variable 'param' resp. Action7/9/D variable '0x80 + param'.

 * If a variable is not accessible from all four actions, it is handled in the action specific functions.

 *

 * @param param variable number (as for VarAction2, for Action7/9/D you have to subtract 0x80 first).

 * @param value returns the value of the variable.

 * @return true iff the variable is known and the value is returned in 'value'.

 */

bool GetGlobalVariable(byte param, uint32 *value)

{

	switch (param) {

		case 0x00: // current date

			*value = max(_date - DAYS_TILL_ORIGINAL_BASE_YEAR, 0);

			return true;

		case 0x01: // current year

			*value = Clamp(_cur_year, ORIGINAL_BASE_YEAR, ORIGINAL_MAX_YEAR) - ORIGINAL_BASE_YEAR;

			return true;

		case 0x02: { // detailed date information: month of year (bit 0-7), day of month (bit 8-12), leap year (bit 15), day of year (bit 16-24)

			YearMonthDay ymd;

			ConvertDateToYMD(_date, &ymd);

			Date start_of_year = ConvertYMDToDate(ymd.year, 0, 1);

	GRFStatus status;          ///< NOSAVE: GRFStatus, enum

	uint32 grf_bugs;           ///< NOSAVE: bugs in this GRF in this run, @see enum GRFBugs

	uint32 param[0x80];        ///< GRF parameters

	uint8 num_params;          ///< Number of used parameters

	uint8 num_valid_params;    ///< NOSAVE: Number of valid parameters (action 0x14)

	uint8 palette;             ///< GRFPalette, bitset

	SmallVector<GRFParameterInfo *, 4> param_info; ///< NOSAVE: extra information about the parameters

	struct GRFConfig *next;    ///< NOSAVE: Next item in the linked list

	bool IsOpenTTDBaseGRF() const;

	const char *GetName() const;

	const char *GetDescription() const;

	void SetSuitablePalette();

};

extern GRFConfig *_all_grfs;          ///< First item in list of all scanned NewGRFs

extern GRFConfig *_grfconfig;         ///< First item in list of current GRF set up

extern GRFConfig *_grfconfig_newgame; ///< First item in list of default GRF set up

extern GRFConfig *_grfconfig_static;  ///< First item in list of static GRF set up

void ScanNewGRFFiles();

const GRFConfig *FindGRFConfig(uint32 grfid, const uint8 *md5sum = NULL);

GRFConfig *GetGRFConfig(uint32 grfid, uint32 mask = 0xFFFFFFFF);

GRFConfig **CopyGRFConfigList(GRFConfig **dst, const GRFConfig *src, bool init_only);

void AppendStaticGRFConfigs(GRFConfig **dst);

void AppendToGRFConfigList(GRFConfig **dst, GRFConfig *el);

void ClearGRFConfigList(GRFConfig **config);

void ResetGRFConfig(bool defaults);

GRFListCompatibility IsGoodGRFConfigList(GRFConfig *grfconfig);

bool FillGRFDetails(GRFConfig *config, bool is_static);

char *GRFBuildParamList(char *dst, const GRFConfig *c, const char *last);

/* In newgrf_gui.cpp */

void ShowNewGRFSettings(bool editable, bool show_params, bool exec_changes, GRFConfig **config);

#ifdef ENABLE_NETWORK

/* For communication about GRFs over the network */

#define UNKNOWN_GRF_NAME_PLACEHOLDER "<Unknown>"

char *FindUnknownGRFName(uint32 grfid, uint8 *md5sum, bool create);

#endif /* ENABLE_NETWORK */

#endif /* NEWGRF_CONFIG_H */

}

static void LoadIntroGame()

{

	_game_mode = GM_MENU;

	ResetGRFConfig(false);

	/* Setup main window */

	ResetWindowSystem();

	SetupColoursAndInitialWindow();

	/* Load the default opening screen savegame */

	if (SaveOrLoad("opntitle.dat", SL_LOAD, DATA_DIR) != SL_OK) {

		GenerateWorld(GWM_EMPTY, 64, 64); // if failed loading, make empty world.

		WaitTillGeneratedWorld();

		SetLocalCompany(COMPANY_SPECTATOR);

	} else {

		SetLocalCompany(COMPANY_FIRST);

	}

	_pause_mode = PM_UNPAUSED;

	_cursor.fix_at = false;

	CheckForMissingGlyphsInLoadedLanguagePack();

	/* Play main theme */

	if (_music_driver->IsSongPlaying()) ResetMusic();

}

void MakeNewgameSettingsLive()

{

#ifdef ENABLE_AI

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

		if (_settings_game.ai_config[c] != NULL) {

			delete _settings_game.ai_config[c];

		}

	}

#endif /* ENABLE_AI */

	_settings_game = _settings_newgame;

#ifdef ENABLE_AI

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

		_settings_game.ai_config[c] = NULL;

		if (_settings_newgame.ai_config[c] != NULL) {

			_settings_game.ai_config[c] = new AIConfig(_settings_newgame.ai_config[c]);

		}