*/

bool CrashLog::MakeCrashLog() const

{

	/* Don't keep looping logging crashes. */

	static bool crashlogged = false;

	if (crashlogged) return false;

	crashlogged = true;

	char filename[MAX_PATH];

	char buffer[65536];

	bool ret = true;

	this->FillCrashLog(buffer, lastof(buffer));

	bool bret = this->WriteCrashLog(buffer, filename, lastof(filename));

	if (bret) {

	} else {

		ret = false;

	}

	/* Don't mention writing crash dumps because not all platforms support it. */

	int dret = this->WriteCrashDump(filename, lastof(filename));

	if (dret < 0) {

		ret = false;

	} else if (dret > 0) {

	}

	bret = this->WriteSavegame(filename, lastof(filename));

	if (bret) {

	} else {

		ret = false;

	}

	bret = this->WriteScreenshot(filename, lastof(filename));

	if (bret) {

	} else {

		ret = false;

	}

	this->SendSurvey();

	return ret;

}

/**

 * Sets a message for the error message handler.

 * @param message The error message of the error.

 */

/* static */ void CrashLog::SetErrorMessage(const std::string &message)

	auto now = std::chrono::steady_clock::now();

	for (auto &cmsg : _chatmsg_list) {

		if (cmsg.remove_time >= now) return true;

	}

	return false;

}

/**

 * Add a text message to the 'chat window' to be shown

 * @param colour The colour this message is to be shown in

 * @param duration The duration of the chat message in seconds

 */

void CDECL NetworkAddChatMessage(TextColour colour, uint duration, const std::string &message)

{

	if (_chatmsg_list.size() == MAX_CHAT_MESSAGES) {

		_chatmsg_list.pop_back();

	}

	ChatMessage *cmsg = &_chatmsg_list.emplace_front();

	cmsg->message = message;

	cmsg->colour = colour;

	cmsg->remove_time = std::chrono::steady_clock::now() + std::chrono::seconds(duration);

	AI::Initialize();

	AI::GetConsoleList(output_iterator, true);

	AI::Uninitialize(true);

	/* We need to initialize the GameScript, so it finds the GSs */

	Game::Initialize();

	Game::GetConsoleList(output_iterator, true);

	Game::Uninitialize(true);

	/* ShowInfo put output to stderr, but version information should go

	 * to stdout; this is the only exception */

#if !defined(_WIN32)

#else

	ShowInfoI(str);

#endif

}

static void WriteSavegameInfo(const char *name)

{

	extern SaveLoadVersion _sl_version;

	uint32 last_ottd_rev = 0;

	byte ever_modified = 0;

	bool removed_newgrfs = false;

	message += "NewGRFs:\n";

	if (_load_check_data.HasNewGrfs()) {

		for (GRFConfig *c = _load_check_data.grfconfig; c != nullptr; c = c->next) {

			fmt::format_to(std::back_inserter(message), "{:08X} {} {}\n", c->ident.grfid,

				FormatArrayAsHex(HasBit(c->flags, GCF_COMPATIBLE) ? c->original_md5sum : c->ident.md5sum), c->filename);

		}

	}

	/* ShowInfo put output to stderr, but version information should go

	 * to stdout; this is the only exception */

#if !defined(_WIN32)

#else

	ShowInfoI(message);

#endif

}

/**

 * Extract the resolution from the given string and store

 * it in the 'res' parameter.

 * @param res variable to store the resolution in.

 * @param s   the string to decompose.

 */

	{

		filename_log[0] = '\0';

		filename_save[0] = '\0';

		filename_screenshot[0] = '\0';

	}

	/** Generate the crash log. */

	bool MakeCrashLog()

	{

		char buffer[65536];

		bool ret = true;

		this->FillCrashLog(buffer, lastof(buffer));

		if (!this->WriteCrashLog(buffer, filename_log, lastof(filename_log))) {

			filename_log[0] = '\0';

			ret = false;

		}

		if (!this->WriteSavegame(filename_save, lastof(filename_save))) {

			filename_save[0] = '\0';

			ret = false;

		}

		if (!this->WriteScreenshot(filename_screenshot, lastof(filename_screenshot))) {

			filename_screenshot[0] = '\0';

			ret = false;

		}

		this->SendSurvey();

		return ret;

	}

	/** Show a dialog with the crash information. */

	void DisplayCrashDialog() const

 * Entry point for the crash handler.

 * @note Not static so it shows up in the backtrace.

 * @param signum the signal that caused us to crash.

 */

static void CDECL HandleCrash(int signum)

{

	/* Disable all handling of signals by us, so we don't go into infinite loops. */

	for (const int *i = _signals_to_handle; i != endof(_signals_to_handle); i++) {

		signal(*i, SIG_DFL);

	}

	if (_gamelog.TestEmergency()) {

		abort();

	}

	if (SaveloadCrashWithMissingNewGRFs()) {

		abort();

	}

	CrashLogUnix log(signum);

	log.MakeCrashLog();

	CrashLog::AfterCrashLogCleanup();

	abort();

}

/* static */ void CrashLog::InitialiseCrashLog()

{

/**

 * This function frees the memory it allocated

 */

void AyStar::Free()

{

	this->openlist_queue.Free(false);

	/* 2nd argument above is false, below is true, to free the values only

	 * once */

	this->openlist_hash.Delete(true);

	this->closedlist_hash.Delete(true);

#ifdef AYSTAR_DEBUG

#endif

}

/**

 * This function make the memory go back to zero.

 * This function should be called when you are using the same instance again.

 */

void AyStar::Clear()

{

	/* Clean the Queue, but not the elements within. That will be done by

	 * the hash. */

	this->openlist_queue.Clear(false);

	/* Clean the hashes */

	this->openlist_hash.Clear(true);

	this->closedlist_hash.Clear(true);

#ifdef AYSTAR_DEBUG

#endif

}

/**

 * This is the function you call to run AyStar.

 * @return Possible values:

 *  - #AYSTAR_FOUND_END_NODE : indicates we found an end node.

 *  - #AYSTAR_NO_PATH : indicates that there was no path found.

 *  - #AYSTAR_STILL_BUSY : indicates we have done some checked, that we did not found the path yet, and that we still have items left to try.

 * @note When the algorithm is done (when the return value is not #AYSTAR_STILL_BUSY) #Clear() is called automatically.

 *       When you stop the algorithm halfway, you should call #Clear() yourself!

 */

int AyStar::Main()

{

	int r, i = 0;

	/* Loop through the OpenList

	 *  Quit if result is no AYSTAR_STILL_BUSY or is more than loops_per_tick */

	while ((r = this->Loop()) == AYSTAR_STILL_BUSY && (this->loops_per_tick == 0 || ++i < this->loops_per_tick)) { }

#ifdef AYSTAR_DEBUG

	switch (r) {

		default: break;

	}

#endif

	if (r != AYSTAR_STILL_BUSY) {

		/* We're done, clean up */

		this->Clear();

	}

	switch (r) {

		case AYSTAR_FOUND_END_NODE: return AYSTAR_FOUND_END_NODE;

		case AYSTAR_EMPTY_OPENLIST:

		case AYSTAR_LIMIT_REACHED:  return AYSTAR_NO_PATH;

/**

 * Adds a node from where to start an algorithm. Multiple nodes can be added

 * if wanted. You should make sure that #Clear() is called before adding nodes

 * if the #AyStar has been used before (though the normal main loop calls

 * #Clear() automatically when the algorithm finishes.

 * @param start_node Node to start with.

 * @param g the cost for starting with this node.

 */

void AyStar::AddStartNode(AyStarNode *start_node, uint g)

{

#ifdef AYSTAR_DEBUG

		TileX(start_node->tile), TileY(start_node->tile), start_node->direction);

#endif

	this->OpenListAdd(nullptr, start_node, 0, g);

}

/**

 * Initialize an #AyStar. You should fill all appropriate fields before

 * calling #Init (see the declaration of #AyStar for which fields are internal).

 */

void AyStar::Init(Hash_HashProc hash, uint num_buckets)

{

	/* Allocated the Hash for the OpenList and ClosedList */

			const HashNode *node;

			used_buckets++;

			for (node = &this->buckets[i]; node != nullptr; node = node->next) collision++;

			if (collision > max_collision) max_collision = collision;

		}

		if (collision >= lengthof(usage)) collision = lengthof(usage) - 1;

		usage[collision]++;

		if (collision > 0 && usage[collision] >= max_usage) {

			max_usage = usage[collision];

		}

	}

		this->num_buckets, this->size, used_buckets, max_collision

	);

	for (i = 0; i <= max_collision; i++) {

		if (usage[i] > 0) {

#if 0

			if (i > 0) {

				uint j;

			}

#endif

		}

	}

}

#endif

/**

 * Cleans the hash, but keeps the memory allocated

 */

void Hash::Clear(bool free_values)

{

	uint i;

#ifdef HASH_STATS

	if (this->size > 2000) this->PrintStatistics();

		}

	}

	Squirrel::RunError(vm, "unknown error");

	return 0;

}

void Squirrel::PrintFunc(HSQUIRRELVM vm, const std::string &s)

{

	/* Check if we have a custom print function */

	SQPrintFunc *func = ((Squirrel *)sq_getforeignptr(vm))->print_func;

	if (func == nullptr) {

	} else {

		(*func)(false, s);

	}

}

void Squirrel::AddMethod(const char *method_name, SQFUNCTION proc, uint nparam, const char *params, void *userdata, int size)

{

	ScriptAllocatorScope alloc_scope(this);

	sq_pushstring(this->vm, method_name, -1);

	if (size != 0) {

	GetOptData mgo(argc - 1, argv + 1, _opts);

	for (;;) {

		int i = mgo.GetOpt();

		if (i == -1) break;

		switch (i) {

			case 'v':

				puts("$Revision$");

				return 0;

			case 'C':

				for (const CmdStruct *cs = _cmd_structs; cs < endof(_cmd_structs); cs++) {

					char flags;

					if (cs->proc == EmitGender) {

						flags = 'g'; // Command needs number of parameters defined by number of genders

					} else if (cs->proc == EmitPlural) {

						flags = 'p'; // Command needs number of parameters defined by plural value

					} else if (cs->flags & C_DONTCOUNT) {

						flags = 'i'; // Command may be in the translation when it is not in base

					} else {

						flags = '0'; // Command needs no parameters

					}

				}

				return 0;

			case 'L':

				for (const PluralForm *pf = _plural_forms; pf < endof(_plural_forms); pf++) {

				}

				return 0;

			case 'P':

				for (size_t j = 0; j < lengthof(_pragmas); j++) {

							_pragmas[j][0], _pragmas[j][1], _pragmas[j][2], _pragmas[j][3]);

				}

				return 0;

			case 't':

				_show_todo |= 1;

				break;

			case 'w':

				_show_todo |= 2;

				break;