/* Try if we can find the currently selected AI */

		this->selected = -1;

		if (GetConfig(slot)->HasScript()) {

			ScriptInfo *info = GetConfig(slot)->GetInfo();

			int i = 0;

					this->selected = i;

					break;

				}

			}

		}

	}

				int y = this->GetWidget<NWidgetBase>(WID_AIL_LIST)->pos_y;

				/* First AI in the list is hardcoded to random */

				if (this->vscroll->IsVisible(0)) {

					DrawString(r.left + WD_MATRIX_LEFT, r.right - WD_MATRIX_LEFT, y + WD_MATRIX_TOP, this->slot == OWNER_DEITY ? STR_AI_CONFIG_NONE : STR_AI_CONFIG_RANDOM_AI, this->selected == -1 ? TC_WHITE : TC_ORANGE);

					y += this->line_height;

				}

					if (this->vscroll->IsVisible(i)) {

						y += this->line_height;

					}

				}

				break;

			}

			case WID_AIL_INFO_BG: {

				AIInfo *selected_info = nullptr;

				}

				/* Some info about the currently selected AI. */

				if (selected_info != nullptr) {

					int y = r.top + WD_FRAMERECT_TOP;

					SetDParamStr(0, selected_info->GetAuthor());

					DrawString(r.left + WD_FRAMETEXT_LEFT, r.right - WD_FRAMETEXT_RIGHT, y, STR_AI_LIST_AUTHOR);

	 * gui.ai_developer_tools is enabled.

	 */

	void RebuildVisibleSettings()

	{

		visible_settings.clear();

			if (no_hide || _settings_client.gui.ai_developer_tools) {

			}

		}

		this->vscroll->SetCount((int)this->visible_settings.size());

	}

	AIInfo::RegisterAPI(engine);

}

AIInfo *AIScannerInfo::SelectRandomAI() const

{

	uint num_random_ais = 0;

		if (i->UseAsRandomAI()) num_random_ais++;

	}

	if (num_random_ais == 0) {

		DEBUG(script, 0, "No suitable AI found, loading 'dummy' AI.");

		return this->info_dummy;

	AIInfo *info = nullptr;

	int version = -1;

	/* See if there is a compatible AI which goes by that name, with the highest

	 *  version which allows loading the requested version */

		if (strcasecmp(ai_name, i->GetName()) == 0 && i->CanLoadFromVersion(versionParam) && (version == -1 || i->GetVersion() > version)) {

			info = i;

		}

	}

	return info;

}

	/* Internally we store libraries as 'library.version' */

	char library_name[1024];

	seprintf(library_name, lastof(library_name), "%s.%d", library, version);

	strtolower(library_name);

	/* Check if the library + version exists */

}

	GameInfo *info = nullptr;

	int version = -1;

	/* See if there is a compatible Game script which goes by that name, with the highest

	 *  version which allows loading the requested version */

		if (strcasecmp(game_name, i->GetName()) == 0 && i->CanLoadFromVersion(versionParam) && (version == -1 || i->GetVersion() > version)) {

			info = i;

		}

	}

	return info;

}

	/* Internally we store libraries as 'library.version' */

	char library_name[1024];

	seprintf(library_name, lastof(library_name), "%s.%d", library, version);

	strtolower(library_name);

	/* Check if the library + version exists */

}

{

	ScriptObject::SetCompany(company);

}

ScriptController::~ScriptController()

{

	}

	this->loaded_library.clear();

}

/* static */ uint ScriptController::GetTick()

	/* Get the current table/class we belong to */

	HSQOBJECT parent;

	sq_getstackobj(vm, 1, &parent);

	char fake_class[1024];

	} else {

		int next_number = ++controller->loaded_library_count;

		/* Create a new fake internal name */

		seprintf(fake_class, lastof(fake_class), "_internalNA%d", next_number);

	this->ClearConfigList();

	if (_game_mode == GM_NORMAL && this->info != nullptr) {

		/* If we're in an existing game and the Script is changed, set all settings

		 *  for the Script that have the random flag to a random value. */

			}

		}

		this->AddRandomDeviation();

	}

}

	this->name = (config->name == nullptr) ? nullptr : stredup(config->name);

	this->info = config->info;

	this->version = config->version;

	this->config_list = nullptr;

	this->is_random = config->is_random;

	}

	this->AddRandomDeviation();

}

ScriptConfig::~ScriptConfig()

{

	}

	return this->config_list;

}

void ScriptConfig::ClearConfigList()

{

	}

	this->settings.clear();

}

void ScriptConfig::AnchorUnchangeableSettings()

{

		}

	}

}

int ScriptConfig::GetSetting(const char *name) const

{

	if (it == this->settings.end()) return this->info->GetSettingDefaultValue(name);

	return (*it).second;

}

void ScriptConfig::SetSetting(const char *name, int value)

{

	const ScriptConfigItem *config_item = this->info->GetConfigItem(name);

	if (config_item == nullptr) return;

	value = Clamp(value, config_item->min_value, config_item->max_value);

	if (it != this->settings.end()) {

		(*it).second = value;

	} else {

		this->settings[stredup(name)] = value;

	}

}

void ScriptConfig::ResetSettings()

{

	}

	this->settings.clear();

}

void ScriptConfig::AddRandomDeviation()

{

		}

	}

}

bool ScriptConfig::HasScript() const

{

}

void ScriptConfig::SettingsToString(char *string, const char *last) const

{

	char *s = string;

	*s = '\0';

		char no[10];

		/* Check if the string would fit in the destination */

		/* If it doesn't fit, skip the next settings */

		if (string + needed_size > last) break;

		s = strecat(s, "=", last);

		s = strecat(s, no, last);

		s = strecat(s, ",", last);

	}

	/* Remove the last ',', but only if at least one setting was saved. */

#include "../safeguards.h"

ScriptInfo::~ScriptInfo()

{

	/* Free all allocated strings */

				free(lbl_map.second);

			}

		}

	}

	this->config_list.clear();

	free(this->author);

	free(this->name);

{

	const SQChar *setting_name;

	if (SQ_FAILED(sq_getstring(vm, -2, &setting_name))) return SQ_ERROR;

	ValidateString(setting_name);

	ScriptConfigItem *config = nullptr;

	}

	if (config == nullptr) {

		char error[1024];

		seprintf(error, lastof(error), "Trying to add labels for non-defined setting '%s'", setting_name);

		this->engine->ThrowError(error);

{

	return &this->config_list;

}

const ScriptConfigItem *ScriptInfo::GetConfigItem(const char *name) const

{

	}

	return nullptr;

}

int ScriptInfo::GetSettingDefaultValue(const char *name) const

{

		/* The default value depends on the difficulty level */

		switch (GetGameSettings().script.settings_profile) {

			default: NOT_REACHED();

		}

	}

	/* There is no such setting */

	return -1;

	/* Scan for scripts */

	this->Scan(this->GetFileName(), this->GetDirectory());

}

void ScriptScanner::Reset()

{

	}

	}

	this->info_list.clear();

	this->info_single_list.clear();

}

}

char *ScriptScanner::GetConsoleList(char *p, const char *last, bool newest_only) const

{

	p += seprintf(p, last, "List of %s:\n", this->GetScannerName());

	const ScriptInfoList &list = newest_only ? this->info_single_list : this->info_list;

		p += seprintf(p, last, "%10s (v%d): %s\n", i->GetName(), i->GetVersion(), i->GetDescription());

	}

	p += seprintf(p, last, "\n");

	return p;

}

	return memcmp(ci->md5sum, checksum.md5sum, sizeof(ci->md5sum)) == 0;

}

bool ScriptScanner::HasScript(const ContentInfo *ci, bool md5sum)

{

	}

	return false;

}

const char *ScriptScanner::FindMainScript(const ContentInfo *ci, bool md5sum)

{

	}

	return nullptr;

}