diff options
Diffstat (limited to 'src/ai')
167 files changed, 19124 insertions, 7079 deletions
diff --git a/src/ai/ai.cpp b/src/ai/ai.cpp deleted file mode 100644 index 01c8dcd68..000000000 --- a/src/ai/ai.cpp +++ /dev/null @@ -1,244 +0,0 @@ -/* $Id$ */ - -/** @file ai.cpp Base for all AIs. */ - -#include "../stdafx.h" -#include "../openttd.h" -#include "../variables.h" -#include "../command_func.h" -#include "../network/network.h" -#include "../core/alloc_func.hpp" -#include "../company_func.h" -#include "../company_base.h" -#include "ai.h" -#include "default/default.h" -#include "trolly/trolly.h" -#include "../signal_func.h" - -AIStruct _ai; -AICompany _ai_company[MAX_COMPANIES]; - -/** - * Dequeues commands put in the queue via AI_PutCommandInQueue. - */ -static void AI_DequeueCommands(CompanyID company) -{ - AICommand *com, *entry_com; - - entry_com = _ai_company[company].queue; - - /* It happens that DoCommandP issues a new DoCommandAI which adds a new command - * to this very same queue (don't argue about this, if it currently doesn't - * happen I can tell you it will happen with AIScript -- TrueLight). If we - * do not make the queue NULL, that commands will be dequeued immediatly. - * Therefor we safe the entry-point to entry_com, and make the queue NULL, so - * the new queue can be safely built up. */ - _ai_company[company].queue = NULL; - _ai_company[company].queue_tail = NULL; - - /* Dequeue all commands */ - while ((com = entry_com) != NULL) { - _current_company = company; - - DoCommandP(com->tile, com->p1, com->p2, com->cmd, com->callback, com->text); - - /* Free item */ - entry_com = com->next; - free(com->text); - free(com); - } -} - -/** - * Needed for SP; we need to delay DoCommand with 1 tick, because else events - * will make infinite loops (AIScript). - */ -static void AI_PutCommandInQueue(CompanyID company, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const char *text = NULL) -{ - AICommand *com; - - if (_ai_company[company].queue_tail == NULL) { - /* There is no item in the queue yet, create the queue */ - _ai_company[company].queue = MallocT<AICommand>(1); - _ai_company[company].queue_tail = _ai_company[company].queue; - } else { - /* Add an item at the end */ - _ai_company[company].queue_tail->next = MallocT<AICommand>(1); - _ai_company[company].queue_tail = _ai_company[company].queue_tail->next; - } - - /* This is our new item */ - com = _ai_company[company].queue_tail; - - /* Assign the info */ - com->tile = tile; - com->p1 = p1; - com->p2 = p2; - com->cmd = cmd; - com->callback = callback; - com->next = NULL; - com->text = text == NULL ? NULL : strdup(text); -} - -/** - * Executes a raw DoCommand for the AI. - */ -CommandCost AI_DoCommandCc(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint32 cmd, CommandCallback *callback, const char *text) -{ - CompanyID old_local_company; - CommandCost res; - - /* If you enable DC_EXEC with DC_QUERY_COST you are a really strange - * person.. should we check for those funny jokes? - */ - - /* First, do a test-run to see if we can do this */ - res = DoCommand(tile, p1, p2, flags & ~DC_EXEC, cmd, text); - /* The command failed, or you didn't want to execute, or you are quering, return */ - if (CmdFailed(res) || !(flags & DC_EXEC) || (flags & DC_QUERY_COST)) { - return res; - } - - /* NetworkSend_Command needs _local_company to be set correctly, so - * adjust it, and put it back right after the function */ - old_local_company = _local_company; - _local_company = _current_company; - -#ifdef ENABLE_NETWORK - /* Send the command */ - if (_networking) { - /* Network is easy, send it to his handler */ - NetworkSend_Command(tile, p1, p2, cmd, callback, text); - } else { -#else - { -#endif - /* If we execute BuildCommands directly in SP, we have a big problem with events - * so we need to delay is for 1 tick */ - AI_PutCommandInQueue(_current_company, tile, p1, p2, cmd, callback, text); - } - - /* Set _local_company back */ - _local_company = old_local_company; - - return res; -} - - -CommandCost AI_DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint32 cmd, const char *text) -{ - return AI_DoCommandCc(tile, p1, p2, flags, cmd, NULL, text); -} - - -/** - * Run 1 tick of the AI. Don't overdo it, keep it realistic. - */ -static void AI_RunTick(CompanyID company) -{ - extern void AiNewDoGameLoop(Company *c); - - Company *c = GetCompany(company); - _current_company = company; - - if (_settings_game.ai.ainew_active) { - AiNewDoGameLoop(c); - } else { - /* Enable all kind of cheats the old AI needs in order to operate correctly... */ - _is_old_ai_company = true; - AiDoGameLoop(c); - _is_old_ai_company = false; - } - - /* AI could change some track, so update signals */ - UpdateSignalsInBuffer(); -} - - -/** - * The gameloop for AIs. - * Handles one tick for all the AIs. - */ -void AI_RunGameLoop() -{ - /* Don't do anything if ai is disabled */ - if (!_ai.enabled) return; - - /* Don't do anything if we are a network-client, or the AI has been disabled */ - if (_networking && (!_network_server || !_settings_game.ai.ai_in_multiplayer)) return; - - /* New tick */ - _ai.tick++; - - /* Make sure the AI follows the difficulty rule.. */ - assert(_settings_game.difficulty.competitor_speed <= 4); - if ((_ai.tick & ((1 << (4 - _settings_game.difficulty.competitor_speed)) - 1)) != 0) return; - - /* Check for AI-client (so joining a network with an AI) */ - if (!_networking || _network_server) { - /* Check if we want to run AIs (server or SP only) */ - const Company *c; - - FOR_ALL_COMPANIES(c) { - if (c->is_ai) { - /* This should always be true, else something went wrong... */ - assert(_ai_company[c->index].active); - - /* Run the script */ - AI_DequeueCommands(c->index); - AI_RunTick(c->index); - } - } - } - - _current_company = OWNER_NONE; -} - -/** - * A new AI sees the day of light. You can do here what ever you think is needed. - */ -void AI_StartNewAI(CompanyID company) -{ - assert(IsValidCompanyID(company)); - - /* Called if a new AI is booted */ - _ai_company[company].active = true; -} - -/** - * This AI company died. Give it some chance to make a final puf. - */ -void AI_CompanyDied(CompanyID company) -{ - /* Called if this AI died */ - _ai_company[company].active = false; - - if (_companies_ainew[company].pathfinder == NULL) return; - - AyStarMain_Free(_companies_ainew[company].pathfinder); - delete _companies_ainew[company].pathfinder; - _companies_ainew[company].pathfinder = NULL; - -} - -/** - * Initialize some AI-related stuff. - */ -void AI_Initialize() -{ - /* First, make sure all AIs are DEAD! */ - AI_Uninitialize(); - - memset(&_ai, 0, sizeof(_ai)); - memset(&_ai_company, 0, sizeof(_ai_company)); - - _ai.enabled = true; -} - -/** - * Deinitializer for AI-related stuff. - */ -void AI_Uninitialize() -{ - for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) AI_CompanyDied(c); -} diff --git a/src/ai/ai.h b/src/ai/ai.h deleted file mode 100644 index 0f18490d5..000000000 --- a/src/ai/ai.h +++ /dev/null @@ -1,115 +0,0 @@ -/* $Id$ */ - -/** @file ai.h Base functions for all AIs. */ - -#ifndef AI_H -#define AI_H - -#include "../network/network.h" -#include "../command_type.h" -#include "../core/random_func.hpp" -#include "../settings_type.h" - -/* How DoCommands look like for an AI */ -struct AICommand { - uint32 tile; - uint32 p1; - uint32 p2; - uint32 cmd; - CommandCallback *callback; - - char *text; - uint uid; - - AICommand *next; -}; - -/* The struct for an AIScript Company */ -struct AICompany { - bool active; ///< Is this AI active? - AICommand *queue; ///< The commands that he has in his queue - AICommand *queue_tail; ///< The tail of this queue -}; - -/* The struct to keep some data about the AI in general */ -struct AIStruct { - /* General */ - bool enabled; ///< Is AI enabled? - uint tick; ///< The current tick (something like _frame_counter, only for AIs) -}; - -extern AIStruct _ai; -extern AICompany _ai_company[MAX_COMPANIES]; - -// ai.c -void AI_StartNewAI(CompanyID company); -void AI_CompanyDied(CompanyID company); -void AI_RunGameLoop(); -void AI_Initialize(); -void AI_Uninitialize(); -CommandCost AI_DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint procc, const char *text = NULL); -CommandCost AI_DoCommandCc(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint procc, CommandCallback *callback, const char *text = NULL); - -/** Is it allowed to start a new AI. - * This function checks some boundries to see if we should launch a new AI. - * @return True if we can start a new AI. - */ -static inline bool AI_AllowNewAI() -{ - /* If disabled, no AI */ - if (!_ai.enabled) - return false; - - /* If in network, but no server, no AI */ - if (_networking && !_network_server) - return false; - - /* If in network, and server, possible AI */ - if (_networking && _network_server) { - /* Do we want AIs in multiplayer? */ - if (!_settings_game.ai.ai_in_multiplayer) - return false; - - /* Only the NewAI is allowed... sadly enough the old AI just doesn't support this - * system, because all commands are delayed by at least 1 tick, which causes - * a big problem, because it uses variables that are only set AFTER the command - * is really executed... */ - if (!_settings_game.ai.ainew_active) - return false; - } - - return true; -} - -#define AI_CHANCE16(a, b) ((uint16) AI_Random() <= (uint16)((65536 * a) / b)) -#define AI_CHANCE16R(a, b, r) ((uint16)(r = AI_Random()) <= (uint16)((65536 * a) / b)) - -/** - * The random-function that should be used by ALL AIs. - */ -static inline uint AI_RandomRange(uint max) -{ - /* We pick RandomRange if we are in SP (so when saved, we do the same over and over) - * but we pick InteractiveRandomRange if we are a network_server or network-client. - */ - if (_networking) - return InteractiveRandomRange(max); - else - return RandomRange(max); -} - -/** - * The random-function that should be used by ALL AIs. - */ -static inline uint32 AI_Random() -{ -/* We pick RandomRange if we are in SP (so when saved, we do the same over and over) - * but we pick InteractiveRandomRange if we are a network_server or network-client. - */ - if (_networking) - return InteractiveRandom(); - else - return Random(); -} - -#endif /* AI_H */ diff --git a/src/ai/ai.hpp b/src/ai/ai.hpp new file mode 100644 index 000000000..bd1c2a907 --- /dev/null +++ b/src/ai/ai.hpp @@ -0,0 +1,102 @@ +/* $Id$ */ + +/** @file ai.hpp Base functions for all AIs. */ + +#ifndef AI_HPP +#define AI_HPP + +#include "api/ai_event_types.hpp" + +#ifndef AI_CONFIG_HPP +struct ltstr { bool operator()(const char *s1, const char *s2) const { return strcmp(s1, s2) < 0; } }; +#endif /* AI_CONFIG_HPP */ +typedef std::map<const char *, class AIInfo *, ltstr> AIInfoList; + + +void CcAI(bool success, TileIndex tile, uint32 p1, uint32 p2); + +class AI { +public: + /** + * Is it possible to start a new AI company? + * @return True if a new AI company can be started. + */ + static bool CanStartNew(); + + /** + * Start a new AI company. + * @param company At which slot the AI company should start. + */ + static void StartNew(CompanyID company); + + /** + * Called every game-tick to let AIs do something. + */ + static void GameLoop(); + + /** + * Get the current AI tick. + */ + static uint GetTick(); + + /** + * Stop a company to be controlled by an AI. + * @param company The company from which the AI needs to detach. + * @pre !IsHumanCompany(company). + */ + static void Stop(CompanyID company); + + /** + * Kill any and all AIs we manage. + */ + static void KillAll(); + + /** + * Initialize the AI system. + */ + static void Initialize(); + + /** + * Uninitialize the AI system + * @param keepConfig Should we keep AIConfigs, or can we free that memory? + */ + static void Uninitialize(bool keepConfig); + + /** + * Reset all AIConfigs, and make them reload their AIInfo. + * If the AIInfo could no longer be found, an error is reported to the user. + */ + static void ResetConfig(); + + /** + * Queue a new event for an AI. + */ + static void NewEvent(CompanyID company, AIEvent *event); + + /** + * Broadcast a new event to all active AIs. + */ + static void BroadcastNewEvent(AIEvent *event, CompanyID skip_company = MAX_COMPANIES); + + /** + * Save data from an AI to a savegame. + */ + static void Save(CompanyID company); + + /** + * Load data for an AI from a savegame. + */ + static void Load(CompanyID company); + + static char *GetConsoleList(char *p, const char *last); + static const AIInfoList *GetInfoList(); + static AIInfo *GetCompanyInfo(const char *name); + static bool ImportLibrary(const char *library, const char *class_name, int version, HSQUIRRELVM vm); + static void Rescan(); + +private: + static uint frame_counter; + static class AIScanner *ai_scanner; +}; + +#endif /* AI_HPP */ diff --git a/src/ai/ai_config.cpp b/src/ai/ai_config.cpp new file mode 100644 index 000000000..f5d22bdaa --- /dev/null +++ b/src/ai/ai_config.cpp @@ -0,0 +1,143 @@ +/* $Id$ */ + +/** @file ai_config.cpp Implementation of AIConfig. */ + +#include "../stdafx.h" +#include "../openttd.h" +#include "../settings_type.h" +#include "ai.hpp" +#include "ai_config.hpp" +#include "ai_info.hpp" + +void AIConfig::ChangeAI(const char *name) +{ + free((void *)this->name); + this->name = (name == NULL) ? NULL : strdup(name); + this->info = (name == NULL) ? NULL : AI::GetCompanyInfo(this->name); + + for (SettingValueList::iterator it = this->settings.begin(); it != this->settings.end(); it++) { + free((void*)(*it).first); + } + this->settings.clear(); +} + +AIConfig::AIConfig(const AIConfig *config) : + name(NULL), + info(NULL) +{ + this->name = (config->name == NULL) ? NULL : strdup(config->name); + this->info = config->info; + + for (SettingValueList::const_iterator it = config->settings.begin(); it != config->settings.end(); it++) { + this->settings[strdup((*it).first)] = (*it).second; + } +} + +AIConfig::~AIConfig() +{ + this->ChangeAI(NULL); +} + +AIInfo *AIConfig::GetInfo() +{ + return this->info; +} + +bool AIConfig::ResetInfo() +{ + this->info = AI::GetCompanyInfo(this->name); + return this->info != NULL; +} + +AIConfig *AIConfig::GetConfig(CompanyID company, bool forceNewgameSetting) +{ + AIConfig **config; + if (!forceNewgameSetting) { + config = (_game_mode == GM_MENU) ? &_settings_newgame.ai_config[company] : &_settings_game.ai_config[company]; + } else { + config = &_settings_newgame.ai_config[company]; + } + if (*config == NULL) *config = new AIConfig(); + return *config; +} + +int AIConfig::GetSetting(const char *name) +{ + assert(this->info != NULL); + + SettingValueList::iterator it = this->settings.find(name); + /* Return the default value if the setting is not set, or if we are in a not-custom difficult level */ + if (it == this->settings.end() || ((_game_mode == GM_MENU) ? _settings_newgame.difficulty.diff_level : _settings_game.difficulty.diff_level) != 3) { + return this->info->GetSettingDefaultValue(name); + } + return (*it).second; +} + +void AIConfig::SetSetting(const char *name, int value) +{ + /* You can only set ai specific settings if an AI is selected. */ + assert(strcmp(name, "start_date") == 0 || this->info != NULL); + + SettingValueList::iterator it = this->settings.find(name); + if (it != this->settings.end()) { + (*it).second = value; + } else { + this->settings[strdup(name)] = value; + } +} + +bool AIConfig::HasAI() +{ + return this->info != NULL; +} + +const char *AIConfig::GetName() +{ + return this->name; +} + +void AIConfig::StringToSettings(const char *value) +{ + char *value_copy = strdup(value); + char *s = value_copy; + + while (s != NULL) { + /* Analyze the string ('name=value,name=value\0') */ + char *item_name = s; + s = strchr(s, '='); + if (s == NULL) break; + if (*s == '\0') break; + *s = '\0'; + s++; + + char *item_value = s; + s = strchr(s, ','); + if (s != NULL) { + *s = '\0'; + s++; + } + + this->SetSetting(item_name, atoi(item_value)); + } + free(value_copy); +} + +void AIConfig::SettingsToString(char *string, int size) +{ + string[0] = '\0'; + for (SettingValueList::iterator it = this->settings.begin(); it != this->settings.end(); it++) { + char no[10]; + snprintf(no, sizeof(no), "%d", (*it).second); + + /* Check if the string would fit in the destination */ + size -= strlen((*it).first) - 1 - strlen(no) - 1; + /* If it doesn't fit, skip the next settings */ + if (size <= 0) return; + + strcat(string, (*it).first); + strcat(string, "="); + strcat(string, no); + strcat(string, ","); + } + string[strlen(string) - 1] = '\0'; +} diff --git a/src/ai/ai_config.hpp b/src/ai/ai_config.hpp new file mode 100644 index 000000000..c628a855f --- /dev/null +++ b/src/ai/ai_config.hpp @@ -0,0 +1,91 @@ +/* $Id$ */ + +/** @file ai_config.hpp AIConfig stores the configuration settings of every AI. */ + +#ifndef AI_CONFIG_HPP +#define AI_CONFIG_HPP + +#include <map> + +#ifndef AI_HPP +struct ltstr { bool operator()(const char *s1, const char *s2) const { return strcmp(s1, s2) < 0; } }; +#endif /* AI_HPP */ + +class AIConfig { +private: + typedef std::map<const char *, int, ltstr> SettingValueList; + +public: + AIConfig() : + name(NULL), + info(NULL) + {} + AIConfig(const AIConfig *config); + ~AIConfig(); + + /** + * Set another AI to be loaded in this slot. + */ + void ChangeAI(const char *name); + + /** + * When ever the AI Scanner is reloaded, all infos become invalid. This + * function tells AIConfig about this. + * @return True if the reset was successfull, false if the AI was no longer + * found. + */ + bool ResetInfo(); + + /** + * Get the AIInfo linked to this AIConfig. + */ + class AIInfo *GetInfo(); + + /** + * Get the config of a company. + */ + static AIConfig *GetConfig(CompanyID company, bool forceNewgameSetting = false); + + /** + * Get the value of a setting for this config. It might fallback to his + * 'info' to find the default value (if not set or if not-custom difficulty + * level). + * @return The (default) value of the setting, or -1 if the setting was not + * found. + */ + int GetSetting(const char *name); + + /** + * Set the value of a setting for this config. + */ + void SetSetting(const char *name, int value); + + /** + * Is this config attached to an AI? + */ + bool HasAI(); + + /** + * Get the name of the AI. + */ + const char *GetName(); + + /** + * Convert a string which is stored in the config file or savegames to + * custom settings of this AI. + */ + void StringToSettings(const char *value); + + /** + * Convert the custom settings to a string that can be stored in the config + * file or savegames. + */ + void SettingsToString(char *string, int size); + +private: + const char *name; + class AIInfo *info; + SettingValueList settings; +}; + +#endif /* AI_CONFIG_HPP */ diff --git a/src/ai/ai_core.cpp b/src/ai/ai_core.cpp new file mode 100644 index 000000000..f0a82f771 --- /dev/null +++ b/src/ai/ai_core.cpp @@ -0,0 +1,254 @@ +/* $Id$ */ + +/** @file ai_core.cpp Implementation of AI. */ + +#include "../stdafx.h" +#include "../openttd.h" +#include "../company_type.h" +#include "../company_base.h" +#include "../company_func.h" +#include "../debug.h" +#include "../network/network.h" +#include "../settings_type.h" +#include "../window_type.h" +#include "../window_func.h" +#include "../command_func.h" +#include "ai.hpp" +#include "ai_info.hpp" +#include "ai_scanner.hpp" +#include "ai_instance.hpp" +#include "ai_config.hpp" + +/* static */ uint AI::frame_counter = 0; +/* static */ AIScanner *AI::ai_scanner = NULL; + +/* static */ bool AI::CanStartNew() +{ + /* Only allow new AIs on the server and only when that is allowed in multiplayer */ + return !_networking || (_network_server && _settings_game.ai.ai_in_multiplayer); +} + +/* static */ void AI::StartNew(CompanyID company) +{ + assert(IsValidCompanyID(company)); + + /* Clients shouldn't start AIs */ + if (_networking && !_network_server) return; + + AIInfo *info = AIConfig::GetConfig(company)->GetInfo(); + if (info == NULL) { + info = AI::ai_scanner->SelectRandomAI(); + assert(info != NULL); + /* Load default data and store the name in the settings */ + AIConfig::GetConfig(company)->ChangeAI(info->GetDirName()); + } + + _current_company = company; + Company *c = GetCompany(company); + + c->ai_info = info; + c->ai_instance = new AIInstance(info); + + InvalidateWindowData(WC_AI_DEBUG, 0, -1); + return; +} + +/* static */ void AI::GameLoop() +{ + /* If we are in networking, only servers run this function, and that only if it is allowed */ + if (_networking && (!_network_server || !_settings_game.ai.ai_in_multiplayer)) return; + + /* The speed with which AIs go, is limited by the 'competitor_speed' */ + AI::frame_counter++; + assert(_settings_game.difficulty.competitor_speed <= 4); + if ((AI::frame_counter & ((1 << (4 - _settings_game.difficulty.competitor_speed)) - 1)) != 0) return; + + const Company *c; + FOR_ALL_COMPANIES(c) { + if (!IsHumanCompany(c->index)) { + _current_company = c->index; + c->ai_instance->GameLoop(); + } + } + + _current_company = OWNER_NONE; +} + +/* static */ uint AI::GetTick() +{ + return AI::frame_counter; +} + +/* static */ void AI::Stop(CompanyID company) +{ + if (_networking && !_network_server) return; + + _current_company = company; + Company *c = GetCompany(company); + + delete c->ai_instance; + c->ai_instance = NULL; + + InvalidateWindowData(WC_AI_DEBUG, 0, -1); +} + +/* static */ void AI::KillAll() +{ + /* It might happen there are no companies .. than we have nothing to loop */ + if (GetCompanyPoolSize() == 0) return; + + const Company *c; + FOR_ALL_COMPANIES(c) { + if (!IsHumanCompany(c->index)) AI::Stop(c->index); + } +} + +/* static */ void AI::Initialize() +{ + if (AI::ai_scanner != NULL) AI::Uninitialize(true); + + AI::frame_counter = 0; + if (AI::ai_scanner == NULL) AI::ai_scanner = new AIScanner(); +} + +/* static */ void AI::Uninitialize(bool keepConfig) +{ + AI::KillAll(); + + if (keepConfig) { + /* Run a rescan, which indexes all AIInfos again, and check if we can + * still load all the AIS, while keeping the configs in place */ + Rescan(); + } else { + delete AI::ai_scanner; + AI::ai_scanner = NULL; + + for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) { + if (_settings_game.ai_config[c] != NULL) { + delete _settings_game.ai_config[c]; + _settings_game.ai_config[c] = NULL; + } + if (_settings_newgame.ai_config[c] != NULL) { + delete _settings_newgame.ai_config[c]; + _settings_newgame.ai_config[c] = NULL; + } + } + } +} + +/* static */ void AI::ResetConfig() +{ + /* Check for both newgame as current game if we can reload the AIInfo insde + * the AIConfig. If not, remove the AI from the list (which will assign + * a random new AI on reload). */ + for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) { + if (_settings_game.ai_config[c] != NULL && _settings_game.ai_config[c]->HasAI()) { + if (!_settings_game.ai_config[c]->ResetInfo()) { + DEBUG(ai, 0, "After a reload, the AI by the name '%s' was no longer found, and removed from the list.", _settings_game.ai_config[c]->GetName()); + _settings_game.ai_config[c]->ChangeAI(NULL); + } + } + if (_settings_newgame.ai_config[c] != NULL && _settings_newgame.ai_config[c]->HasAI()) { + if (!_settings_newgame.ai_config[c]->ResetInfo()) { + DEBUG(ai, 0, "After a reload, the AI by the name '%s' was no longer found, and removed from the list.", _settings_newgame.ai_config[c]->GetName()); + _settings_newgame.ai_config[c]->ChangeAI(NULL); + } + } + } +} + +/* static */ void AI::NewEvent(CompanyID company, AIEvent *event) +{ + /* Clients should ignore events */ + if (_networking && !_network_server) return; + + /* Only AIs can have an event-queue */ + if (!IsValidCompanyID(company) || IsHumanCompany(company)) return; + + /* Queue the event */ + CompanyID old_company = _current_company; + _current_company = company; + AIEventController::InsertEvent(event); + _current_company = old_company; +} + +/* static */ void AI::BroadcastNewEvent(AIEvent *event, CompanyID skip_company) +{ + /* Clients should ignore events */ + if (_networking && !_network_server) return; + + /* Try to send the event to all AIs */ + for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) { + if (c != skip_company) AI::NewEvent(c, event); + } +} + +void CcAI(bool success, TileIndex tile, uint32 p1, uint32 p2) +{ + AIObject::SetLastCommandRes(success); + + if (!success) { + AIObject::SetLastError(AIError::StringToError(_error_message)); + } else { + AIObject::IncreaseDoCommandCosts(AIObject::GetLastCost()); + } + + GetCompany(_current_company)->ai_instance->Continue(); +} + +/* static */ void AI::Save(CompanyID company) +{ + if (!_networking || _network_server) { + assert(IsValidCompanyID(company)); + assert(GetCompany(company)->ai_instance != NULL); + + CompanyID old_company = _current_company; + _current_company = company; + GetCompany(company)->ai_instance->Save(); + _current_company = old_company; + } else { + AIInstance::SaveEmpty(); + } +} + +/* static */ void AI::Load(CompanyID company) +{ + if (!_networking || _network_server) { + assert(IsValidCompanyID(company)); + assert(GetCompany(company)->ai_instance != NULL); + + CompanyID old_company = _current_company; + _current_company = company; + GetCompany(company)->ai_instance->Load(); + _current_company = old_company; + } else { + /* Read, but ignore, the load data */ + AIInstance::LoadEmpty(); + } +} + +/* static */ char *AI::GetConsoleList(char *p, const char *last) +{ + return AI::ai_scanner->GetAIConsoleList(p, last); +} + +/* static */ const AIInfoList *AI::GetInfoList() +{ + return AI::ai_scanner->GetAIInfoList(); +} + +/* static */ AIInfo *AI::GetCompanyInfo(const char *name) +{ + return AI::ai_scanner->FindAI(name); +} + +/* static */ bool AI::ImportLibrary(const char *library, const char *class_name, int version, HSQUIRRELVM vm) +{ + return AI::ai_scanner->ImportLibrary(library, class_name, version, vm, GetCompany(_current_company)->ai_instance->GetController()); +} + +/* static */ void AI::Rescan() +{ + AI::ai_scanner->RescanAIDir(); + ResetConfig(); +} diff --git a/src/ai/ai_gui.cpp b/src/ai/ai_gui.cpp new file mode 100644 index 000000000..8272cc966 --- /dev/null +++ b/src/ai/ai_gui.cpp @@ -0,0 +1,257 @@ +/* $Id$ */ + +/** @file ai_gui.cpp Window for configuring the AIs */ + +#include "../stdafx.h" +#include "../openttd.h" +#include "../gui.h" +#include "../window_gui.h" +#include "../company_func.h" +#include "../company_base.h" +#include "../company_gui.h" +#include "../economy_func.h" +#include "../variables.h" +#include "../cargotype.h" +#include "../strings_func.h" +#include "../core/alloc_func.hpp" +#include "../window_func.h" +#include "../date_func.h" +#include "../gfx_func.h" +#include "../debug.h" +#include "../command_func.h" +#include "../network/network.h" + +#include "ai.hpp" +#include "api/ai_types.hpp" +#include "api/ai_controller.hpp" +#include "api/ai_object.hpp" +#include "api/ai_log.hpp" +#include "ai_info.hpp" + +#include "table/strings.h" +#include "../table/sprites.h" + +struct AIDebugWindow : public Window { + enum AIDebugWindowWidgets { + AID_WIDGET_CLOSEBOX = 0, + AID_WIDGET_CAPTION, + AID_WIDGET_VIEW, + AID_WIDGET_NAME_TEXT, + AID_WIDGET_RELOAD_TOGGLE, + AID_WIDGET_LOG_PANEL, + AID_WIDGET_SCROLLBAR, + AID_WIDGET_UNUSED_1, + AID_WIDGET_UNUSED_2, + AID_WIDGET_UNUSED_3, + AID_WIDGET_UNUSED_4, + AID_WIDGET_UNUSED_5, + AID_WIDGET_UNUSED_6, + AID_WIDGET_UNUSED_7, + + AID_WIDGET_COMPANY_BUTTON_START, + AID_WIDGET_COMPANY_BUTTON_END = AID_WIDGET_COMPANY_BUTTON_START + 14, + }; + + static CompanyID ai_debug_company; + int redraw_timer; + + AIDebugWindow(const WindowDesc *desc, WindowNumber number) : Window(desc, number) + { + /* Disable the companies who are not active or not an AI */ + for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) { + this->SetWidgetDisabledState(i + AID_WIDGET_COMPANY_BUTTON_START, !IsValidCompanyID(i) || !GetCompany(i)->is_ai); + } + this->DisableWidget(AID_WIDGET_RELOAD_TOGGLE); + + this->vscroll.cap = 14; + this->vscroll.pos = 0; + this->resize.step_height = 12; + + if (ai_debug_company != INVALID_COMPANY) this->LowerWidget(ai_debug_company + AID_WIDGET_COMPANY_BUTTON_START); + + this->FindWindowPlacementAndResize(desc); + } + + virtual void OnPaint() + { + /* Check if the currently selected company is still active. */ + if (ai_debug_company == INVALID_COMPANY || !IsValidCompanyID(ai_debug_company)) { + if (ai_debug_company != INVALID_COMPANY) { + /* Raise and disable the widget for the previous selection. */ + this->RaiseWidget(ai_debug_company + AID_WIDGET_COMPANY_BUTTON_START); + this->DisableWidget(ai_debug_company + AID_WIDGET_COMPANY_BUTTON_START); + + ai_debug_company = INVALID_COMPANY; + } + + for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) { + if (IsValidCompanyID(i) && GetCompany(i)->is_ai) { + /* Lower the widget corresponding to this company. */ + this->LowerWidget(i + AID_WIDGET_COMPANY_BUTTON_START); + + ai_debug_company = i; + break; + } + } + } + + /* Update "Reload AI" button */ + this->SetWidgetDisabledState(AID_WIDGET_RELOAD_TOGGLE, ai_debug_company == INVALID_COMPANY); + + /* Draw standard stuff */ + this->DrawWidgets(); + + /* If there are no active companies, don't display anything else. */ + if (ai_debug_company == INVALID_COMPANY) return; + + /* Paint the company icons */ + for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) { + if (!IsValidCompanyID(i) || !GetCompany(i)->is_ai) { + /* Check if we have the company as an active company */ + if (!this->IsWidgetDisabled(i + AID_WIDGET_COMPANY_BUTTON_START)) { + /* Bah, company gone :( */ + this->DisableWidget(i + AID_WIDGET_COMPANY_BUTTON_START); + + /* We need a repaint */ + this->SetDirty(); + } + continue; + } + + /* Check if we have the company marked as inactive */ + if (this->IsWidgetDisabled(i + AID_WIDGET_COMPANY_BUTTON_START)) { + /* New AI! Yippie :p */ + this->EnableWidget(i + AID_WIDGET_COMPANY_BUTTON_START); + + /* We need a repaint */ + this->SetDirty(); + } + + byte x = (i == ai_debug_company) ? 1 : 0; + DrawCompanyIcon(i, (i % 8) * 37 + 13 + x, (i < 8 ? 0 : 13) + 16 + x); + } + + /* Draw the AI name */ + AIInfo *info = GetCompany(ai_debug_company)->ai_info; + assert(info != NULL); + DoDrawString(info->GetName(), 7, 47, TC_BLACK); + + CompanyID old_company = _current_company; + _current_company = ai_debug_company; + AILog::LogData *log = (AILog::LogData *)AIObject::GetLogPointer(); + _current_company = old_company; + + SetVScrollCount(this, (log == NULL) ? 0 : log->used); + this->InvalidateWidget(AID_WIDGET_SCROLLBAR); + if (log == NULL) return; + + int y = 6; + for (int i = this->vscroll.pos; i < (this->vscroll.cap + this->vscroll.pos); i++) { + uint pos = (log->count + log->pos - i) % log->count; + if (log->lines[pos] == NULL) break; + + uint colour; + switch (log->type[pos]) { + case AILog::LOG_SQ_INFO: colour = TC_BLACK; break; + case AILog::LOG_SQ_ERROR: colour = TC_RED; break; + case AILog::LOG_INFO: colour = TC_BLACK; break; + case AILog::LOG_WARNING: colour = TC_YELLOW; break; + case AILog::LOG_ERROR: colour = TC_RED; break; + default: colour = TC_BLACK; break; + } + + DoDrawStringTruncated(log->lines[pos], 7, this->widget[AID_WIDGET_LOG_PANEL].top + y, colour, this->widget[AID_WIDGET_LOG_PANEL].right - this->widget[AID_WIDGET_LOG_PANEL].left - 14); + y += 12; + } + } + + virtual void OnClick(Point pt, int widget) + { + /* Check which button is clicked */ + if (IsInsideMM(widget, AID_WIDGET_COMPANY_BUTTON_START, AID_WIDGET_COMPANY_BUTTON_END + 1)) { + /* Is it no on disable? */ + if (!this->IsWidgetDisabled(widget)) { + this->RaiseWidget(ai_debug_company + AID_WIDGET_COMPANY_BUTTON_START); + ai_debug_company = (CompanyID)(widget - AID_WIDGET_COMPANY_BUTTON_START); + this->LowerWidget(ai_debug_company + AID_WIDGET_COMPANY_BUTTON_START); + this->SetDirty(); + } + } + if (widget == AID_WIDGET_RELOAD_TOGGLE && !this->IsWidgetDisabled(widget)) { + /* First kill the company of the AI, then start a new one. This should start the current AI again */ + DoCommandP(0, 2, ai_debug_company, CMD_COMPANY_CTRL); + DoCommandP(0, 1, 0, CMD_COMPANY_CTRL); + } + } + + virtual void OnTimeout() + { + this->RaiseWidget(AID_WIDGET_RELOAD_TOGGLE); + this->SetDirty(); + } + + virtual void OnInvalidateData(int data = 0) + { + if (data == -1 || ai_debug_company == data) this->SetDirty(); + } + + virtual void OnResize(Point new_size, Point delta) + { + this->vscroll.cap += delta.y / (int)this->resize.step_height; + } +}; + +CompanyID AIDebugWindow::ai_debug_company = INVALID_COMPANY; + +static const Widget _ai_debug_widgets[] = { +{ WWT_CLOSEBOX, RESIZE_NONE, COLOUR_GREY, 0, 10, 0, 13, STR_00C5, STR_018B_CLOSE_WINDOW}, // AID_WIDGET_CLOSEBOX +{ WWT_CAPTION, RESIZE_RIGHT, COLOUR_GREY, 11, 298, 0, 13, STR_AI_DEBUG, STR_018C_WINDOW_TITLE_DRAG_THIS}, // AID_WIDGET_CAPTION +{ WWT_PANEL, RESIZE_RIGHT, COLOUR_GREY, 0, 298, 14, 40, 0x0, STR_NULL}, // AID_WIDGET_VIEW + +{ WWT_PANEL, RESIZE_RIGHT, COLOUR_GREY, 0, 149, 41, 60, 0x0, STR_AI_DEBUG_NAME_TIP}, // AID_WIDGET_NAME_TEXT +{ WWT_PUSHTXTBTN, RESIZE_LR, COLOUR_GREY, 150, 298, 41, 60, STR_AI_DEBUG_RELOAD, STR_AI_DEBUG_RELOAD_TIP}, // AID_WIDGET_RELOAD_TOGGLE +{ WWT_PANEL, RESIZE_RB, COLOUR_GREY, 0, 286, 61, 240, 0x0, STR_NULL}, // AID_WIDGET_LOG_PANEL +{ WWT_SCROLLBAR, RESIZE_LRB, COLOUR_GREY, 287, 298, 61, 228, STR_NULL, STR_0190_SCROLL_BAR_SCROLLS_LIST}, // AID_WIDGET_SCROLLBAR +/* As this is WIP, leave the next few so we can work a bit with the GUI */ +{ WWT_EMPTY, RESIZE_NONE, COLOUR_GREY, 0, 298, 101, 120, 0x0, STR_NULL}, // AID_WIDGET_UNUSED_1 +{ WWT_EMPTY, RESIZE_NONE, COLOUR_GREY, 0, 298, 121, 140, 0x0, STR_NULL}, // AID_WIDGET_UNUSED_2 +{ WWT_EMPTY, RESIZE_NONE, COLOUR_GREY, 0, 298, 141, 160, 0x0, STR_NULL}, // AID_WIDGET_UNUSED_3 +{ WWT_EMPTY, RESIZE_NONE, COLOUR_GREY, 0, 298, 161, 180, 0x0, STR_NULL}, // AID_WIDGET_UNUSED_4 +{ WWT_EMPTY, RESIZE_NONE, COLOUR_GREY, 0, 298, 181, 200, 0x0, STR_NULL}, // AID_WIDGET_UNUSED_5 +{ WWT_EMPTY, RESIZE_NONE, COLOUR_GREY, 0, 298, 201, 220, 0x0, STR_NULL}, // AID_WIDGET_UNUSED_6 +{ WWT_EMPTY, RESIZE_NONE, COLOUR_GREY, 0, 298, 221, 240, 0x0, STR_NULL}, // AID_WIDGET_UNUSED_7 + +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 2, 38, 14, 26, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, // AID_WIDGET_COMPANY_BUTTON_START +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 39, 75, 14, 26, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 76, 112, 14, 26, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 113, 149, 14, 26, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 150, 186, 14, 26, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 187, 223, 14, 26, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 224, 260, 14, 26, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 261, 297, 14, 26, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 2, 38, 27, 39, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 39, 75, 27, 39, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 76, 112, 27, 39, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 113, 149, 27, 39, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 150, 186, 27, 39, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 187, 223, 27, 39, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, +{ WWT_PANEL, RESIZE_NONE, COLOUR_GREY, 224, 260, 27, 39, 0x0, STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY}, // AID_WIDGET_COMPANY_BUTTON_END +{ WWT_RESIZEBOX, RESIZE_LRTB, COLOUR_GREY, 287, 298, 229, 240, STR_NULL, STR_RESIZE_BUTTON}, +{ WIDGETS_END}, +}; + +static const WindowDesc _ai_debug_desc = { + WDP_AUTO, WDP_AUTO, 299, 241, 299, 241, + WC_AI_DEBUG, WC_NONE, + WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_RESIZABLE, + _ai_debug_widgets +}; + +void ShowAIDebugWindow() +{ + if (!_networking || _network_server) { + AllocateWindowDescFront<AIDebugWindow>(&_ai_debug_desc, 0); + } else { + ShowErrorMessage(INVALID_STRING_ID, STR_AI_DEBUG_SERVER_ONLY, 0, 0); + } +} diff --git a/src/ai/ai_gui.hpp b/src/ai/ai_gui.hpp new file mode 100644 index 000000000..c5c7ad2ee --- /dev/null +++ b/src/ai/ai_gui.hpp @@ -0,0 +1,10 @@ +/* $Id$ */ + +/** @file ai_gui.hpp Window for configuring the AIs */ + +#ifndef AI_GUI_HPP +#define AI_GUI_HPP + +void ShowAIDebugWindow(); + +#endif /* AI_GUI_HPP */ diff --git a/src/ai/ai_info.cpp b/src/ai/ai_info.cpp new file mode 100644 index 000000000..0eead0302 --- /dev/null +++ b/src/ai/ai_info.cpp @@ -0,0 +1,319 @@ +/* $Id$ */ + +/** @file ai_info.cpp Implementation of AIFileInfo */ + +#include "../stdafx.h" +#include "../core/alloc_func.hpp" + +#include <squirrel.h> +#include "../script/squirrel.hpp" +#include "../script/squirrel_helper.hpp" +#include "../script/squirrel_class.hpp" +#include "../script/squirrel_std.hpp" +#include "ai.hpp" +#include "ai_info.hpp" +#include "ai_scanner.hpp" +#include "api/ai_controller.hpp" +#include "../settings_type.h" +#include "../openttd.h" + +AIFileInfo::~AIFileInfo() +{ + this->engine->ReleaseObject(this->SQ_instance); + free((void *)this->author); + free((void *)this->name); + free((void *)this->description); + free((void *)this->date); + free((void *)this->instance_name); + free(this->script_name); + free(this->dir_name); + free(this->SQ_instance); +} + +const char *AIFileInfo::GetAuthor() +{ + if (this->author == NULL) this->author = this->engine->CallStringMethodStrdup(*this->SQ_instance, "GetAuthor"); + return this->author; +} + +const char *AIFileInfo::GetName() +{ + if (this->name == NULL) this->name = this->engine->CallStringMethodStrdup(*this->SQ_instance, "GetName"); + return this->name; +} + +const char *AIFileInfo::GetDescription() +{ + if (this->description == NULL) this->description = this->engine->CallStringMethodStrdup(*this->SQ_instance, "GetDescription"); + return this->description; +} + +int AIFileInfo::GetVersion() +{ + return this->engine->CallIntegerMethod(*this->SQ_instance, "GetVersion"); +} + +void AIFileInfo::GetSettings() +{ + this->engine->CallMethod(*this->SQ_instance, "GetSettings", NULL, -1); +} + +const char *AIFileInfo::GetDate() +{ + if (this->date == NULL) this->date = this->engine->CallStringMethodStrdup(*this->SQ_instance, "GetDate"); + return this->date; +} + +const char *AIFileInfo::GetInstanceName() +{ + if (this->instance_name == NULL) this->instance_name = this->engine->CallStringMethodStrdup(*this->SQ_instance, "CreateInstance"); + return this->instance_name; +} + +bool AIFileInfo::AllowStartup() +{ + return true; +} + +const char *AIFileInfo::GetDirName() +{ + return this->dir_name; +} + +const char *AIFileInfo::GetScriptName() +{ + return this->script_name; +} + +void AIFileInfo::CheckMethods(SQInteger *res, const char *name) +{ + if (!this->engine->MethodExists(*this->SQ_instance, name)) { + char error[1024]; + snprintf(error, sizeof(error), "your AIFileInfo doesn't have the method '%s'", name); + this->engine->ThrowError(error); + *res = SQ_ERROR; + } +} + +/* static */ SQInteger AIFileInfo::Constructor(HSQUIRRELVM vm, AIFileInfo *info) +{ + SQInteger res = 0; + + /* Set some basic info from the parent */ + info->SQ_instance = MallocT<SQObject>(1); + Squirrel::GetInstance(vm, info->SQ_instance, 2); + /* Make sure the instance stays alive over time */ + sq_addref(vm, info->SQ_instance); + info->base = ((AIScanner *)Squirrel::GetGlobalPointer(vm)); + info->engine = info->base->GetEngine(); + + /* Check if all needed fields are there */ + info->CheckMethods(&res, "GetAuthor"); + info->CheckMethods(&res, "GetName"); + info->CheckMethods(&res, "GetDescription"); + info->CheckMethods(&res, "GetVersion"); + info->CheckMethods(&res, "GetDate"); + info->CheckMethods(&res, "CreateInstance"); + + /* Abort if one method was missing */ + if (res != 0) return res; + + info->script_name = strdup(info->base->GetCurrentScript()); + info->dir_name = strdup(info->base->GetCurrentDirName()); + + return 0; +} + +/* static */ SQInteger AIInfo::Constructor(HSQUIRRELVM vm) +{ + /* Get the AIInfo */ + SQUserPointer instance; + sq_getinstanceup(vm, 2, &instance, 0); + AIInfo *info = (AIInfo *)instance; + + SQInteger res = AIFileInfo::Constructor(vm, info); + if (res != 0) return res; + + AIConfigItem config; + config.name = strdup("start_date"); + config.description = strdup("The amount of months after the start of the last AI, this AI will start (give or take)."); + config.min_value = 0; + config.max_value = 120; + config.easy_value = 48; + config.medium_value = 24; + config.hard_value = 12; + config.custom_value = 24; + config.flags = AICONFIG_NONE; + info->config_list.push_back(config); + + /* Check if we have settings */ + if (info->engine->MethodExists(*info->SQ_instance, "GetSettings")) { + info->GetSettings(); + } + + /* Remove the link to the real instance, else it might get deleted by RegisterAI() */ + sq_setinstanceup(vm, 2, NULL); + /* Register the AI to the base system */ + info->base->RegisterAI(info); + return 0; +} + +/* static */ SQInteger AIInfo::DummyConstructor(HSQUIRRELVM vm) +{ + /* Get the AIInfo */ + SQUserPointer instance; + sq_getinstanceup(vm, 2, &instance, 0); + AIInfo *info = (AIInfo *)instance; + + SQInteger res = AIFileInfo::Constructor(vm, info); + if (res != 0) return res; + + /* Remove the link to the real instance, else it might get deleted by RegisterAI() */ + sq_setinstanceup(vm, 2, NULL); + /* Register the AI to the base system */ + info->base->SetDummyAI(info); + return 0; +} + +AIInfo::~AIInfo() +{ + /* Free all allocated strings */ + for (AIConfigItemList::iterator it = this->config_list.begin(); it != this->config_list.end(); it++) { + free((char *)(*it).name); + } + this->config_list.clear(); +} + +SQInteger AIInfo::AddSetting(HSQUIRRELVM vm) +{ + AIConfigItem config; + memset(&config, 0, sizeof(config)); + int items = 0; + + /* Read the table, and find all properties we care about */ + sq_pushnull(vm); + while (SQ_SUCCEEDED(sq_next(vm, -2))) { + const SQChar *sqkey; + sq_getstring(vm, -2, &sqkey); + const char *key = FS2OTTD(sqkey); + + if (strcmp(key, "name") == 0) { + const SQChar *sqvalue; + sq_getstring(vm, -1, &sqvalue); + config.name = strdup(FS2OTTD(sqvalue)); + char *s; + /* Don't allow '=' and ',' in configure setting names, as we need those + * 2 chars to nicely store the settings as a string. */ + while ((s = (char *)strchr(config.name, '=')) != NULL) *s = '_'; + while ((s = (char *)strchr(config.name, ',')) != NULL) *s = '_'; + items |= 0x001; + } else if (strcmp(key, "description") == 0) { + const SQChar *sqdescription; + sq_getstring(vm, -1, &sqdescription); + config.description = strdup(FS2OTTD(sqdescription)); + items |= 0x002; + } else if (strcmp(key, "min_value") == 0) { + SQInteger res; + sq_getinteger(vm, -1, &res); + config.min_value = res; + items |= 0x004; + } else if (strcmp(key, "max_value") == 0) { + SQInteger res; + sq_getinteger(vm, -1, &res); + config.max_value = res; + items |= 0x008; + } else if (strcmp(key, "easy_value") == 0) { + SQInteger res; + sq_getinteger(vm, -1, &res); + config.easy_value = res; + items |= 0x010; + } else if (strcmp(key, "medium_value") == 0) { + SQInteger res; + sq_getinteger(vm, -1, &res); + config.medium_value = res; + items |= 0x020; + } else if (strcmp(key, "hard_value") == 0) { + SQInteger res; + sq_getinteger(vm, -1, &res); + config.hard_value = res; + items |= 0x040; + } else if (strcmp(key, "custom_value") == 0) { + SQInteger res; + sq_getinteger(vm, -1, &res); + config.custom_value = res; + items |= 0x080; + } else if (strcmp(key, "flags") == 0) { + SQInteger res; + sq_getinteger(vm, -1, &res); + config.flags = (AIConfigFlags)res; + items |= 0x100; + } else { + char error[1024]; + snprintf(error, sizeof(error), "unknown setting property '%s'", key); + this->engine->ThrowError(error); + return SQ_ERROR; + } + + sq_pop(vm, 2); + } + sq_pop(vm, 1); + + /* Make sure all properties are defined */ + if (items != 0x1FF) { + char error[1024]; + snprintf(error, sizeof(error), "please define all properties of a setting"); + this->engine->ThrowError(error); + return SQ_ERROR; + } + + this->config_list.push_back(config); + return 0; +} + +const AIConfigItemList *AIInfo::GetConfigList() +{ + return &this->config_list; +} + +int AIInfo::GetSettingDefaultValue(const char *name) +{ + for (AIConfigItemList::iterator it = this->config_list.begin(); it != this->config_list.end(); it++) { + if (strcmp((*it).name, name) != 0) continue; + /* The default value depends on the difficulty level */ + switch ((_game_mode == GM_MENU) ? _settings_newgame.difficulty.diff_level : _settings_game.difficulty.diff_level) { + case 0: return (*it).easy_value; + case 1: return (*it).medium_value; + case 2: return (*it).hard_value; + case 3: return (*it).custom_value; + default: NOT_REACHED(); + } + } + + /* There is no such setting */ + return -1; +} + +/* static */ SQInteger AILibrary::Constructor(HSQUIRRELVM vm) +{ + /* Create a new AIFileInfo */ + AILibrary *library = new AILibrary(); + + SQInteger res = AIFileInfo::Constructor(vm, library); + if (res != 0) return res; + + /* Register the Library to the base system */ + library->base->RegisterLibrary(library); + + return 0; +} + +/* static */ SQInteger AILibrary::Import(HSQUIRRELVM vm) +{ + SQConvert::SQAutoFreePointers ptr; + const char *library = GetParam(SQConvert::ForceType<const char *>(), vm, 2, &ptr); + const char *class_name = GetParam(SQConvert::ForceType<const char *>(), vm, 3, &ptr); + int version = GetParam(SQConvert::ForceType<int>(), vm, 4, &ptr); + + if (!AI::ImportLibrary(library, class_name, version, vm)) return -1; + return 1; +} diff --git a/src/ai/ai_info.hpp b/src/ai/ai_info.hpp new file mode 100644 index 000000000..d50b89584 --- /dev/null +++ b/src/ai/ai_info.hpp @@ -0,0 +1,153 @@ +/* $Id$ */ + +/** @file ai_info.hpp AIInfo keeps track of all information of an AI, like Author, Description, ... */ + +#ifndef AI_INFO +#define AI_INFO + +#include <list> +#include "api/ai_object.hpp" + +enum AIConfigFlags { + AICONFIG_NONE = 0x0, + AICONFIG_RANDOM = 0x1, //!< When randomizing the AI, pick any value between min_value and max_value when on custom difficulty setting. + AICONFIG_BOOLEAN = 0x2, //!< This value is a boolean (either 0 (false) or 1 (true) ). +}; + +struct AIConfigItem { + const char *name; //!< The name of the configuration setting. + const char *description; //!< The description of the configuration setting. + int min_value; //!< The minimal value this configuration setting can have. + int max_value; //!< The maximal value this configuration setting can have. + int custom_value; //!< The default value on custom difficulty setting. + int easy_value; //!< The default value on easy difficulty setting. + int medium_value; //!< The default value on medium difficulty setting. + int hard_value; //!< The default value on hard difficulty setting. + AIConfigFlags flags; //!< Flags for the configuration setting. +}; + +typedef std::list<AIConfigItem> AIConfigItemList; + +class AIFileInfo : public AIObject { +public: + friend class AIInfo; + friend class AILibrary; + + AIFileInfo() : author(NULL), name(NULL), description(NULL), date(NULL), instance_name(NULL) {}; + ~AIFileInfo(); + + /** + * Get the Author of the AI. + */ + const char *GetAuthor(); + + /** + * Get the Name of the AI. + */ + const char *GetName(); + + /** + * Get the description of the AI. + */ + const char *GetDescription(); + + /** + * Get the version of the AI. + */ + int GetVersion(); + + /** + * Get the settings of the AI. + */ + void GetSettings(); + + /** + * Get the date of the AI. + */ + const char *GetDate(); + + /** + * Get the name of the instance of the AI to create. + */ + const char *GetInstanceName(); + + /** + * Check if we can start this AI. + */ + bool AllowStartup(); + + /** + * Get the name of the dir this AI is in. + */ + const char *GetDirName(); + + /** + * Get the complete script name of this AI. + */ + const char *GetScriptName(); + + /** + * Check if a given method exists. + */ + void CheckMethods(SQInteger *res, const char *name); + + /** + * Process the creation of a FileInfo object. + */ + static SQInteger Constructor(HSQUIRRELVM vm, AIFileInfo *info); + +private: + class Squirrel *engine; + HSQOBJECT *SQ_instance; + char *script_name; + char *dir_name; + class AIScanner *base; + const char *author; + const char *name; + const char *description; + const char *date; + const char *instance_name; +}; + +class AIInfo : public AIFileInfo { +public: + static const char *GetClassName() { return "AIInfo"; } + + ~AIInfo(); + + /** + * Create an AI, using this AIInfo as start-template. + */ + static SQInteger Constructor(HSQUIRRELVM vm); + static SQInteger DummyConstructor(HSQUIRRELVM vm); + + /** + * Get the config list for this AI. + */ + const AIConfigItemList *GetConfigList(); + + /** + * Set a setting. + */ + SQInteger AddSetting(HSQUIRRELVM vm); + + /** + * Get the default value for a setting. + */ + int GetSettingDefaultValue(const char *name); + +private: + AIConfigItemList config_list; +}; + +class AILibrary : public AIFileInfo { +public: + /** + * Create an AI, using this AIInfo as start-template. + */ + static SQInteger Constructor(HSQUIRRELVM vm); + + static SQInteger Import(HSQUIRRELVM vm); +}; + +#endif /* AI_INFO */ diff --git a/src/ai/ai_info_dummy.cpp b/src/ai/ai_info_dummy.cpp new file mode 100644 index 000000000..a060a0a65 --- /dev/null +++ b/src/ai/ai_info_dummy.cpp @@ -0,0 +1,66 @@ +/* $Id$ */ + +#include <squirrel.h> +#include "../stdafx.h" + +/* The reason this exists in C++, is that a user can trash his ai/ dir, + * leaving no AIs available. The complexity to solve this is insane, and + * therefor the alternative is used, and make sure there is always an AI + * available, no matter what the situation is. By defining it in C++, there + * is simply now way a user can delete it, and therefor safe to use. It has + * to be noted that this AI is complete invisible for the user, and impossible + * to select manual. It is a fail-over in case no AIs are available. + */ + +const SQChar dummy_script_info[] = _SC(" \n\ +class DummyAI extends AIInfo { \n\ + function GetAuthor() { return \"OpenTTD NoAI Developers Team\"; } \n\ + function GetName() { return \"DummyAI\"; } \n\ + function GetDescription() { return \"A Dummy AI that is loaded when your ai/ dir is empty\"; }\n\ + function GetVersion() { return 1; } \n\ + function GetDate() { return \"2008-07-26\"; } \n\ + function CreateInstance() { return \"DummyAI\"; } \n\ +} \n\ + \n\ +RegisterDummyAI(DummyAI()); \n\ +"); + +const SQChar dummy_script[] = _SC(" \n\ +class DummyAI extends AIController { \n\ + function Start() { \n\ + AILog.Error(\"No suitable AI found to load.\"); \n\ + AILog.Error(\"This AI is a dummy AI and won't do anything.\"); \n\ + AILog.Error(\"Please add one or several AIs in your ai/ directory.\"); \n\ + } \n\ +} \n\ +"); + +void AI_CreateAIInfoDummy(HSQUIRRELVM vm) +{ + sq_pushroottable(vm); + + /* Load and run the script */ + if (SQ_SUCCEEDED(sq_compilebuffer(vm, dummy_script_info, scstrlen(dummy_script_info), _SC("dummy"), SQTrue))) { + sq_push(vm, -2); + if (SQ_SUCCEEDED(sq_call(vm, 1, SQFalse, SQTrue))) { + sq_pop(vm, 1); + return; + } + } + NOT_REACHED(); +} + +void AI_CreateAIDummy(HSQUIRRELVM vm) +{ + sq_pushroottable(vm); + + /* Load and run the script */ + if (SQ_SUCCEEDED(sq_compilebuffer(vm, dummy_script, scstrlen(dummy_script), _SC("dummy"), SQTrue))) { + sq_push(vm, -2); + if (SQ_SUCCEEDED(sq_call(vm, 1, SQFalse, SQTrue))) { + sq_pop(vm, 1); + return; + } + } + NOT_REACHED(); +} diff --git a/src/ai/ai_instance.cpp b/src/ai/ai_instance.cpp new file mode 100644 index 000000000..a0612498d --- /dev/null +++ b/src/ai/ai_instance.cpp @@ -0,0 +1,628 @@ +/* $Id$ */ + +/** @file ai_instance.cpp Implementation of AIInstance. */ + +#include "../stdafx.h" +#include "../openttd.h" +#include "../debug.h" +#include "../company_func.h" +#include "../core/alloc_func.hpp" +#include "../string_func.h" +#include "../settings_type.h" +#include "../company_base.h" +#include "../saveload/saveload.h" +#include "table/strings.h" + +#include <squirrel.h> +#include "../script/squirrel.hpp" +#include "../script/squirrel_helper.hpp" +#include "../script/squirrel_class.hpp" +#include "../script/squirrel_std.hpp" +#include "ai.hpp" +#include "api/ai_controller.hpp" +#include "ai_info.hpp" +#include "ai_storage.hpp" +#include "ai_instance.hpp" + +/* Convert all AI related classes to Squirrel data. + * Note: this line a marker in squirrel_export.sh. Do not change! */ +#include "api/ai_abstractlist.hpp.sq" +#include "api/ai_accounting.hpp.sq" +#include "api/ai_airport.hpp.sq" +#include "api/ai_base.hpp.sq" +#include "api/ai_bridge.hpp.sq" +#include "api/ai_bridgelist.hpp.sq" +#include "api/ai_cargo.hpp.sq" +#include "api/ai_cargolist.hpp.sq" +#include "api/ai_company.hpp.sq" +#include "api/ai_controller.hpp.sq" +#include "api/ai_date.hpp.sq" +#include "api/ai_depotlist.hpp.sq" +#include "api/ai_engine.hpp.sq" +#include "api/ai_enginelist.hpp.sq" +#include "api/ai_error.hpp.sq" +#include "api/ai_event.hpp.sq" +#include "api/ai_event_types.hpp.sq" +#include "api/ai_execmode.hpp.sq" +#include "api/ai_gamesettings.hpp.sq" +#include "api/ai_group.hpp.sq" +#include "api/ai_grouplist.hpp.sq" +#include "api/ai_industry.hpp.sq" +#include "api/ai_industrylist.hpp.sq" +#include "api/ai_industrytype.hpp.sq" +#include "api/ai_industrytypelist.hpp.sq" +#include "api/ai_list.hpp.sq" +#include "api/ai_log.hpp.sq" +#include "api/ai_map.hpp.sq" +#include "api/ai_marine.hpp.sq" +#include "api/ai_order.hpp.sq" +#include "api/ai_rail.hpp.sq" +#include "api/ai_railtypelist.hpp.sq" +#include "api/ai_road.hpp.sq" +#include "api/ai_sign.hpp.sq" +#include "api/ai_station.hpp.sq" +#include "api/ai_stationlist.hpp.sq" +#include "api/ai_subsidy.hpp.sq" +#include "api/ai_subsidylist.hpp.sq" +#include "api/ai_testmode.hpp.sq" +#include "api/ai_tile.hpp.sq" +#include "api/ai_tilelist.hpp.sq" +#include "api/ai_town.hpp.sq" +#include "api/ai_townlist.hpp.sq" +#include "api/ai_tunnel.hpp.sq" +#include "api/ai_vehicle.hpp.sq" +#include "api/ai_vehiclelist.hpp.sq" + +/* static */ AIInstance *AIInstance::current_instance = NULL; + +AIStorage::~AIStorage() +{ + /* Free our pointers */ + if (event_data != NULL) AIEventController::FreeEventPointer(); + if (log_data != NULL) AILog::FreeLogPointer(); +} + +static void PrintFunc(bool error_msg, const SQChar *message) +{ + /* Convert to OpenTTD internal capable string */ + AIController::Print(error_msg, FS2OTTD(message)); +} + +AIInstance::AIInstance(AIInfo *info) : + controller(NULL), + storage(NULL), + engine(NULL), + instance(NULL), + is_started(false), + is_dead(false), + suspend(0), + callback(NULL) +{ + /* Set the instance already, so we can use AIObject::Set commands */ + GetCompany(_current_company)->ai_instance = this; + AIInstance::current_instance = this; + + this->controller = new AIController(); + this->storage = new AIStorage(); + this->engine = new Squirrel(); + this->engine->SetPrintFunction(&PrintFunc); + + /* The import method is available at a very early stage */ + this->engine->AddMethod("import", &AILibrary::Import, 4, "?ssi"); + + /* Register the AIController */ + SQAIController_Register(this->engine); + + /* Load and execute the script for this AI */ + const char *script_name = info->GetScriptName(); + if (strcmp(script_name, "%_dummy") == 0) { + extern void AI_CreateAIDummy(HSQUIRRELVM vm); + AI_CreateAIDummy(this->engine->GetVM()); + } else if (!this->engine->LoadScript(script_name)) { + this->Died(); + return; + } + + /* Create the main-class */ + this->instance = MallocT<SQObject>(1); + if (!this->engine->CreateClassInstance(info->GetInstanceName(), this->controller, this->instance)) { + this->Died(); + return; + } + + /* Register the API functions and classes */ + this->RegisterAPI(); + + /* Run the constructor if it exists. Don't allow any DoCommands in it. */ + if (this->engine->MethodExists(*this->instance, "constructor")) { + AIObject::SetAllowDoCommand(false); + this->engine->CallMethod(*this->instance, "constructor"); + AIObject::SetAllowDoCommand(true); + } +} + +AIInstance::~AIInstance() +{ + if (engine != NULL) delete this->engine; + delete this->storage; + delete this->controller; + free(this->instance); +} + +void AIInstance::RegisterAPI() +{ +/* Register all classes */ + squirrel_register_std(this->engine); + SQAIAbstractList_Register(this->engine); + SQAIAccounting_Register(this->engine); + SQAIAirport_Register(this->engine); + SQAIBase_Register(this->engine); + SQAIBridge_Register(this->engine); + SQAIBridgeList_Register(this->engine); + SQAIBridgeList_Length_Register(this->engine); + SQAICargo_Register(this->engine); + SQAICargoList_Register(this->engine); + SQAICargoList_IndustryAccepting_Register(this->engine); + SQAICargoList_IndustryProducing_Register(this->engine); + SQAICompany_Register(this->engine); + SQAIDate_Register(this->engine); + SQAIDepotList_Register(this->engine); + SQAIEngine_Register(this->engine); + SQAIEngineList_Register(this->engine); + SQAIError_Register(this->engine); + SQAIEvent_Register(this->engine); + SQAIEventCompanyBankrupt_Register(this->engine); + SQAIEventCompanyInTrouble_Register(this->engine); + SQAIEventCompanyMerger_Register(this->engine); + SQAIEventCompanyNew_Register(this->engine); + SQAIEventController_Register(this->engine); + SQAIEventEngineAvailable_Register(this->engine); + SQAIEventEnginePreview_Register(this->engine); + SQAIEventIndustryClose_Register(this->engine); + SQAIEventIndustryOpen_Register(this->engine); + SQAIEventStationFirstVehicle_Register(this->engine); + SQAIEventSubsidyAwarded_Register(this->engine); + SQAIEventSubsidyExpired_Register(this->engine); + SQAIEventSubsidyOffer_Register(this->engine); + SQAIEventSubsidyOfferExpired_Register(this->engine); + SQAIEventTest_Register(this->engine); + SQAIEventVehicleCrashed_Register(this->engine); + SQAIEventVehicleLost_Register(this->engine); + SQAIEventVehicleUnprofitable_Register(this->engine); + SQAIEventVehicleWaitingInDepot_Register(this->engine); + SQAIExecMode_Register(this->engine); + SQAIGameSettings_Register(this->engine); + SQAIGroup_Register(this->engine); + SQAIGroupList_Register(this->engine); + SQAIIndustry_Register(this->engine); + SQAIIndustryList_Register(this->engine); + SQAIIndustryList_CargoAccepting_Register(this->engine); + SQAIIndustryList_CargoProducing_Register(this->engine); + SQAIIndustryType_Register(this->engine); + SQAIIndustryTypeList_Register(this->engine); + SQAIList_Register(this->engine); + SQAILog_Register(this->engine); + SQAIMap_Register(this->engine); + SQAIMarine_Register(this->engine); + SQAIOrder_Register(this->engine); + SQAIRail_Register(this->engine); + SQAIRailTypeList_Register(this->engine); + SQAIRoad_Register(this->engine); + SQAISign_Register(this->engine); + SQAIStation_Register(this->engine); + SQAIStationList_Register(this->engine); + SQAIStationList_Vehicle_Register(this->engine); + SQAISubsidy_Register(this->engine); + SQAISubsidyList_Register(this->engine); + SQAITestMode_Register(this->engine); + SQAITile_Register(this->engine); + SQAITileList_Register(this->engine); + SQAITileList_IndustryAccepting_Register(this->engine); + SQAITileList_IndustryProducing_Register(this->engine); + SQAITileList_StationType_Register(this->engine); + SQAITown_Register(this->engine); + SQAITownList_Register(this->engine); + SQAITunnel_Register(this->engine); + SQAIVehicle_Register(this->engine); + SQAIVehicleList_Register(this->engine); + SQAIVehicleList_Station_Register(this->engine); + + this->engine->SetGlobalPointer(this->engine); +} + +void AIInstance::Continue() +{ + assert(this->suspend < 0); + this->suspend = -this->suspend - 1; +} + +void AIInstance::Died() +{ + DEBUG(ai, 0, "The AI died unexpectedly."); + this->is_dead = true; + + delete this->engine; + this->engine = NULL; +} + +void AIInstance::GameLoop() +{ + if (this->is_dead) return; + this->controller->ticks++; + + if (this->suspend < -1) this->suspend++; // Multiplayer suspend, increase up to -1. + if (this->suspend < 0) return; // Multiplayer suspend, wait for Continue(). + if (--this->suspend > 0) return; // Singleplayer suspend, decrease to 0. + + /* If there is a callback to call, call that first */ + if (this->callback != NULL) { + try { + this->callback(this); + } catch (AI_VMSuspend e) { + this->suspend = e.GetSuspendTime(); + this->callback = e.GetSuspendCallback(); + + return; + } + } + + this->suspend = 0; + this->callback = NULL; + + if (!this->is_started) { + /* Start the AI by calling Start() */ + try { + if (!this->engine->CallMethod(*this->instance, "Start", _settings_game.ai.ai_max_opcode_till_suspend)) this->Died(); + } catch (AI_VMSuspend e) { + this->suspend = e.GetSuspendTime(); + this->callback = e.GetSuspendCallback(); + } + + this->is_started = true; + return; + } + + /* Continue the VM */ + try { + if (!this->engine->Resume(_settings_game.ai.ai_max_opcode_till_suspend)) this->Died(); + } catch (AI_VMSuspend e) { + this->suspend = e.GetSuspendTime(); + this->callback = e.GetSuspendCallback(); + } +} + +/* static */ void AIInstance::DoCommandReturn(AIInstance *instance) +{ + instance->engine->InsertResult(AIObject::GetLastCommandRes()); +} + +/* static */ void AIInstance::DoCommandReturnVehicleID(AIInstance *instance) +{ + instance->engine->InsertResult(AIObject::GetNewVehicleID()); +} + +/* static */ void AIInstance::DoCommandReturnSignID(AIInstance *instance) +{ + instance->engine->InsertResult(AIObject::GetNewSignID()); +} + +/* static */ void AIInstance::DoCommandReturnGroupID(AIInstance *instance) +{ + instance->engine->InsertResult(AIObject::GetNewGroupID()); +} + +/* static */ AIStorage *AIInstance::GetStorage() +{ + assert(IsValidCompanyID(_current_company) && !IsHumanCompany(_current_company)); + return GetCompany(_current_company)->ai_instance->storage; +} + +/* + * All data is stored in the following format: + * First 1 byte indicating if there is a data blob at all. + * 1 byte indicating the type of data. + * The data itself, this differs per type: + * - integer: a binary representation of the integer (int32). + * - string: First one byte with the string length, then a 0-terminated char + * array. The string can't be longer then 255 bytes (including + * terminating '\0'). + * - array: All data-elements of the array are saved recursive in this + * format, and ended with an element of the type + * SQSL_ARRAY_TABLE_END. + * - table: All key/value pairs are saved in this format (first key 1, then + * value 1, then key 2, etc.). All keys and values can have an + * arbitrary type (as long as it is supported by the save function + * of course). The table is ended with an element of the type + * SQSL_ARRAY_TABLE_END. + * - bool: A single byte with value 1 representing true and 0 false. + * - null: No data. + */ + +/** The type of the data that follows in the savegame. */ +enum SQSaveLoadType { + SQSL_INT = 0x00, ///< The following data is an integer. + SQSL_STRING = 0x01, ///< The following data is an string. + SQSL_ARRAY = 0x02, ///< The following data is an array. + SQSL_TABLE = 0x03, ///< The following data is an table. + SQSL_BOOL = 0x04, ///< The following data is a boolean. + SQSL_NULL = 0x05, ///< A null variable. + SQSL_ARRAY_TABLE_END = 0xFF, ///< Marks the end of an array or table, no data follows. +}; + +static byte _ai_sl_byte; + +static const SaveLoad _ai_byte[] = { + SLEG_VAR(_ai_sl_byte, SLE_UINT8), + SLE_END() +}; + +enum { + AISAVE_MAX_DEPTH = 25, ///< The maximum recursive depth for items stored in the savegame. +}; + +/* static */ bool AIInstance::SaveObject(HSQUIRRELVM vm, SQInteger index, int max_depth, bool test) +{ + if (max_depth == 0) { + AILog::Error("Savedata can only be nested to 5 deep. No data saved."); + return false; + } + + switch (sq_gettype(vm, index)) { + case OT_INTEGER: { + if (!test) { + _ai_sl_byte = SQSL_INT; + SlObject(NULL, _ai_byte); + } + SQInteger res; + sq_getinteger(vm, index, &res); + if (!test) { + int value = (int)res; + SlArray(&value, 1, SLE_INT32); + } + return true; + } + + case OT_STRING: { + if (!test) { + _ai_sl_byte = SQSL_STRING; + SlObject(NULL, _ai_byte); + } + const SQChar *res; + sq_getstring(vm, index, &res); + /* @bug if a string longer than 512 characters is given to FS2OTTD, the + * internal buffer overflows. */ + const char *buf = FS2OTTD(res); + size_t len = strlen(buf) + 1; + if (len >= 255) { + AILog::Error("Maximum string length is 254 chars. No data saved."); + return false; + } + if (!test) { + _ai_sl_byte = (byte)len; + SlObject(NULL, _ai_byte); + SlArray((void*)buf, len, SLE_CHAR); + } + return true; + } + + case OT_ARRAY: { + if (!test) { + _ai_sl_byte = SQSL_ARRAY; + SlObject(NULL, _ai_byte); + } + sq_pushnull(vm); + while (SQ_SUCCEEDED(sq_next(vm, index - 1))) { + /* Store the value */ + bool res = SaveObject(vm, -1, max_depth - 1, test); + sq_pop(vm, 2); + if (!res) { + sq_pop(vm, 1); + return false; + } + } + sq_pop(vm, 1); + if (!test) { + _ai_sl_byte = SQSL_ARRAY_TABLE_END; + SlObject(NULL, _ai_byte); + } + return true; + } + + case OT_TABLE: { + if (!test) { + _ai_sl_byte = SQSL_TABLE; + SlObject(NULL, _ai_byte); + } + sq_pushnull(vm); + while (SQ_SUCCEEDED(sq_next(vm, index - 1))) { + /* Store the key + value */ + bool res = SaveObject(vm, -2, max_depth - 1, test) && SaveObject(vm, -1, max_depth - 1, test); + sq_pop(vm, 2); + if (!res) { + sq_pop(vm, 1); + return false; + } + } + sq_pop(vm, 1); + if (!test) { + _ai_sl_byte = SQSL_ARRAY_TABLE_END; + SlObject(NULL, _ai_byte); + } + return true; + } + + case OT_BOOL: { + if (!test) { + _ai_sl_byte = SQSL_BOOL; + SlObject(NULL, _ai_byte); + } + SQBool res; + sq_getbool(vm, index, &res); + if (!test) { + _ai_sl_byte = res ? 1 : 0; + SlObject(NULL, _ai_byte); + } + return true; + } + + case OT_NULL: { + if (!test) { + _ai_sl_byte = SQSL_NULL; + SlObject(NULL, _ai_byte); + } + return true; + } + + default: + AILog::Error("You tried to save unsupported type. No data saved."); + return false; + } +} + +/* static */ void AIInstance::SaveEmpty() +{ + _ai_sl_byte = 0; + SlObject(NULL, _ai_byte); +} + +void AIInstance::Save() +{ + /* Don't save data if the AI didn't start yet. */ + if (this->engine == NULL) { + SaveEmpty(); + return; + } + + /* We don't want to be interrupted during the save function. */ + AIObject::SetAllowDoCommand(false); + + HSQOBJECT savedata; + if (this->engine->MethodExists(*this->instance, "Save")) { + this->engine->CallMethod(*this->instance, "Save", &savedata); + if (!sq_istable(savedata)) { + AILog::Error("Save function should return a table."); + _ai_sl_byte = 0; + SlObject(NULL, _ai_byte); + AIObject::SetAllowDoCommand(true); + return; + } + HSQUIRRELVM vm = this->engine->GetVM(); + sq_pushobject(vm, savedata); + if (SaveObject(vm, -1, AISAVE_MAX_DEPTH, true)) { + _ai_sl_byte = 1; + SlObject(NULL, _ai_byte); + SaveObject(vm, -1, AISAVE_MAX_DEPTH, false); + } else { + _ai_sl_byte = 0; + SlObject(NULL, _ai_byte); + } + sq_pop(vm, 1); + } else { + AILog::Warning("Save function is not implemented"); + _ai_sl_byte = 0; + SlObject(NULL, _ai_byte); + } + + AIObject::SetAllowDoCommand(true); +} + +/* static */ bool AIInstance::LoadObjects(HSQUIRRELVM vm) +{ + SlObject(NULL, _ai_byte); + switch (_ai_sl_byte) { + case SQSL_INT: { + int value; + SlArray(&value, 1, SLE_INT32); + if (vm != NULL) sq_pushinteger(vm, (SQInteger)value); + return true; + } + + case SQSL_STRING: { + SlObject(NULL, _ai_byte); + static char buf[256]; + SlArray(buf, _ai_sl_byte, SLE_CHAR); + if (vm != NULL) sq_pushstring(vm, OTTD2FS(buf), -1); + return true; + } + + case SQSL_ARRAY: { + if (vm != NULL) sq_newarray(vm, 0); + while (LoadObjects(vm)) { + if (vm != NULL) sq_arrayappend(vm, -2); + /* The value is popped from the stack by squirrel. */ + } + return true; + } + + case SQSL_TABLE: { + if (vm != NULL) sq_newtable(vm); + while (LoadObjects(vm)) { + LoadObjects(vm); + if (vm != NULL) sq_rawset(vm, -3); + /* The key (-2) and value (-1) are popped from the stack by squirrel. */ + } + return true; + } + + case SQSL_BOOL: { + SlObject(NULL, _ai_byte); + if (vm != NULL) sq_pushinteger(vm, (SQBool)(_ai_sl_byte != 0)); + return true; + } + + case SQSL_NULL: { + if (vm != NULL) sq_pushnull(vm); + return true; + } + + case SQSL_ARRAY_TABLE_END: { + return false; + } + + default: NOT_REACHED(); + } +} + +/* static */ void AIInstance::LoadEmpty() +{ + SlObject(NULL, _ai_byte); + /* Check if there was anything saved at all. */ + if (_ai_sl_byte == 0) return; + + LoadObjects(NULL); +} + +bool AIInstance::Load() +{ + HSQUIRRELVM vm = (this->engine == NULL) ? NULL : this->engine->GetVM(); + + SlObject(NULL, _ai_byte); + /* Check if there was anything saved at all. */ + if (_ai_sl_byte == 0) return true; + AIObject::SetAllowDoCommand(false); + + if (vm != NULL) { + /* Go to the instance-root */ + sq_pushobject(vm, *this->instance); + /* Find the function-name inside the script */ + sq_pushstring(vm, OTTD2FS("Load"), -1); + if (SQ_FAILED(sq_get(vm, -2))) sq_pushnull(vm); + sq_pushobject(vm, *this->instance); + } + + LoadObjects(vm); + + if (this->engine != NULL) { + if (this->engine->MethodExists(*this->instance, "Load")) { + sq_call(vm, 2, SQFalse, SQFalse); + } else { + AILog::Warning("Loading failed: there was data for the AI to load, but the AI does not have a Load() function."); + } + } + + /* Pop 1) the object instance, 2) the function name, 3) the instance again, 4) the table. */ + if (vm != NULL) sq_pop(vm, 4); + + AIObject::SetAllowDoCommand(true); + return true; +} diff --git a/src/ai/ai_instance.hpp b/src/ai/ai_instance.hpp new file mode 100644 index 000000000..d953c3915 --- /dev/null +++ b/src/ai/ai_instance.hpp @@ -0,0 +1,140 @@ +/* $Id$ */ + +/** @file ai_instance.hpp The AIInstance tracks an AI. */ + +#ifndef AI_INSTANCE_HPP +#define AI_INSTANCE_HPP + +/** + * The callback function when an AI suspends. + */ +typedef void (AISuspendCallbackProc)(class AIInstance *instance); + +/** + * A throw-class that is given when the VM wants to suspend. + */ +class AI_VMSuspend { +public: + AI_VMSuspend(int time, AISuspendCallbackProc *callback) : + time(time), + callback(callback) + {} + + int GetSuspendTime() { return time; } + AISuspendCallbackProc *GetSuspendCallback() { return callback; } + +private: + int time; + AISuspendCallbackProc *callback; +}; + +class AIInstance { +public: + AIInstance(class AIInfo *info); + ~AIInstance(); + + /** + * An AI in multiplayer waits for the server to handle his DoCommand. + * It keeps waiting for this until this function is called. + */ + void Continue(); + + /** + * Run the GameLoop of an AI. + */ + void GameLoop(); + + /** + * Get the storage of this AI. + */ + static class AIStorage *GetStorage(); + + /** + * Return a true/false reply for a DoCommand. + */ + static void DoCommandReturn(AIInstance *instance); + + /** + * Return a VehicleID reply for a DoCommand. + */ + static void DoCommandReturnVehicleID(AIInstance *instance); + + /** + * Return a SignID reply for a DoCommand. + */ + static void DoCommandReturnSignID(AIInstance *instance); + + /** + * Return a GroupID reply for a DoCommand. + */ + static void DoCommandReturnGroupID(AIInstance *instance); + + /** + * Get the controller attached to the instance. + */ + class AIController *GetController() { return controller; } + + /** + * Call the AI Save function and save all data in the savegame. + */ + void Save(); + + /** + * Don't save any data in the savegame. + */ + static void SaveEmpty(); + + /** + * Load data from a savegame and call the AI Load function if it + * exists. + * @return True if the loading was successfull. + */ + bool Load(); + + /** + * Load and discard data from a savegame. + */ + static void LoadEmpty(); + +private: + static class AIInstance *current_instance; //!< Static current AIInstance, so we can register AIs. + + class AIController *controller; + class AIStorage *storage; + class Squirrel *engine; + SQObject *instance; + + bool is_started; + bool is_dead; + int suspend; + AISuspendCallbackProc *callback; + + /** + * Register all API functions to the VM. + */ + void RegisterAPI(); + + /** + * Tell the AI it died. + */ + void Died(); + + /** + * Save one object (int / string / arrray / table) to the savegame. + * @param index The index on the squirrel stack of the element to save. + * @param max_depth The maximum depth recursive arrays / tables will be stored + * with before an error is returned. + * @param test If true, don't really store the data but only check if it is + * valid. + * @return True if the saving was successfull. + */ + static bool SaveObject(HSQUIRRELVM vm, SQInteger index, int max_depth, bool test); + + /** + * Load all objects from a savegame. + * @return True if the loading was successfull. + */ + static bool LoadObjects(HSQUIRRELVM vm); +}; + +#endif /* AI_INSTANCE_HPP */ diff --git a/src/ai/ai_scanner.cpp b/src/ai/ai_scanner.cpp new file mode 100644 index 000000000..68d53660d --- /dev/null +++ b/src/ai/ai_scanner.cpp @@ -0,0 +1,395 @@ +/* $Id$ */ + +/** @file ai_scanner.cpp allows scanning AI scripts */ + +#include "../stdafx.h" +#include "../debug.h" +#include "../openttd.h" +#include "../string_func.h" +#include "../fileio_func.h" +#include "../fios.h" +#include "../network/network.h" +#include "../core/random_func.hpp" +#include <sys/types.h> +#include <sys/stat.h> + +#include <squirrel.h> +#include "../script/squirrel.hpp" +#include "../script/squirrel_helper.hpp" +#include "../script/squirrel_class.hpp" +#include "ai.hpp" +#include "ai_info.hpp" +#include "ai_scanner.hpp" +#include "api/ai_controller.hpp" + +void AIScanner::ScanDir(const char *dirname, bool library_dir, char *library_depth) +{ + extern bool FiosIsValidFile(const char *path, const struct dirent *ent, struct stat *sb); + extern bool FiosIsHiddenFile(const struct dirent *ent); + + struct stat sb; + struct dirent *dirent; + DIR *dir; + char d_name[MAX_PATH]; + char script_name[MAX_PATH]; + dir = ttd_opendir(dirname); + /* Dir not found, so do nothing */ + if (dir == NULL) return; + + /* Walk all dirs trying to find a dir in which 'main.nut' exists */ + while ((dirent = readdir(dir)) != NULL) { + ttd_strlcpy(d_name, FS2OTTD(dirent->d_name), sizeof(d_name)); + + /* Valid file, not '.' or '..', not hidden */ + if (!FiosIsValidFile(dirname, dirent, &sb)) continue; + if (strcmp(d_name, ".") == 0 || strcmp(d_name, "..") == 0) continue; + if (FiosIsHiddenFile(dirent) && strncasecmp(d_name, PERSONAL_DIR, strlen(d_name)) != 0) continue; + + if (S_ISDIR(sb.st_mode)) { + /* Create the full-length script-name */ + ttd_strlcpy(script_name, dirname, sizeof(script_name)); + ttd_strlcat(script_name, d_name, sizeof(script_name)); + ttd_strlcat(script_name, PATHSEP, sizeof(script_name)); + + if (library_dir && library_depth == NULL) { + ScanDir(script_name, library_dir, d_name); + continue; + } + } + if (S_ISREG(sb.st_mode)) { + if (library_dir) continue; + + char *ext = strrchr(d_name, '.'); + if (ext == NULL || strcasecmp(ext, ".tar") != 0) continue; + + /* Create the full path to the tarfile */ + char tarname[MAX_PATH]; + ttd_strlcpy(tarname, dirname, sizeof(tarname)); + ttd_strlcat(tarname, d_name, sizeof(tarname)); + + /* Now the script-name starts with the first dir in the tar */ + if (FioTarFirstDir(tarname) == NULL) continue; + ttd_strlcpy(script_name, "%aitar%", sizeof(tarname)); + ttd_strlcat(script_name, FioTarFirstDir(tarname), sizeof(script_name)); + FioTarAddLink(script_name, FioTarFirstDir(tarname)); + + /* The name of the AI is the name of the tar minus the .tar */ + *ext = '\0'; + } + + if (!library_dir) { + /* We look for the file 'info.nut' inside the AI dir.. if it doesn't exists, it isn't an AI */ + ttd_strlcat(script_name, "info.nut", sizeof(script_name)); + if (FioCheckFileExists(script_name, AI_DIR)) { + char load_script[MAX_PATH]; + ttd_strlcpy(load_script, script_name, sizeof(load_script)); + + /* Remove the 'info.nut' part and replace it with 'main.nut' */ + script_name[strlen(script_name) - 8] = '\0'; + ttd_strlcat(script_name, "main.nut", sizeof(script_name)); + + DEBUG(ai, 6, "[script] Loading script '%s' for AI handling", load_script); + this->current_script = script_name; + this->current_dir = d_name; + this->engine->LoadScript(load_script); + } + } else { + /* We look for the file 'library.nut' inside the library dir.. */ + ttd_strlcat(script_name, "library.nut", sizeof(script_name)); + if (FioCheckFileExists(script_name, AI_DIR)) { + char load_script[MAX_PATH]; + char dir_name[MAX_PATH]; + char d_name_2[MAX_PATH]; + /* In case the directory has a dot in it, ignore it, as that is the + * indicator for multiple versions of the same library */ + ttd_strlcpy(d_name_2, d_name, sizeof(d_name_2)); + char *e = strrchr(d_name_2, '.'); + if (e != NULL) *e = '\0'; + + ttd_strlcpy(load_script, script_name, sizeof(load_script)); + ttd_strlcpy(dir_name, library_depth, sizeof(dir_name)); + ttd_strlcat(dir_name, ".", sizeof(dir_name)); + ttd_strlcat(dir_name, d_name_2, sizeof(dir_name)); + + /* Remove the 'library.nut' part and replace it with 'main.nut' */ + script_name[strlen(script_name) - 11] = '\0'; + ttd_strlcat(script_name, "main.nut", sizeof(script_name)); + + DEBUG(ai, 6, "[script] Loading script '%s' for Squirrel library", load_script); + this->current_script = script_name; + this->current_dir = dir_name; + this->engine->LoadScript(load_script); + } + } + } + closedir(dir); +} + +void AIScanner::ScanAIDir() +{ + char buf[MAX_PATH]; + Searchpath sp; + + FOR_ALL_SEARCHPATHS(sp) { + FioAppendDirectory(buf, MAX_PATH, sp, AI_DIR); + if (FileExists(buf)) this->ScanDir(buf, false); + ttd_strlcat(buf, "library" PATHSEP, MAX_PATH); + if (FileExists(buf)) this->ScanDir(buf, true); + } +} + +void AIScanner::RescanAIDir() +{ + extern void ScanForTarFiles(); + ScanForTarFiles(); + this->ScanAIDir(); +} + +AIScanner::AIScanner() +{ + this->engine = new Squirrel(); + + /* Create the AIInfo class, and add the RegisterAI function */ + DefSQClass <AIInfo> SQAIInfo("AIInfo"); + SQAIInfo.PreRegister(engine); + SQAIInfo.AddConstructor<void (AIInfo::*)(), 1>(engine, "x"); + SQAIInfo.DefSQAdvancedMethod(this->engine, &AIInfo::AddSetting, "AddSetting"); + SQAIInfo.PostRegister(engine); + this->engine->AddMethod("RegisterAI", &AIInfo::Constructor, 2, "tx"); + /* Create the AILibrary class, and add the RegisterLibrary function */ + this->engine->AddClassBegin("AILibrary"); + this->engine->AddClassEnd(); + this->engine->AddMethod("RegisterLibrary", &AILibrary::Constructor, 2, "tx"); + + /* Mark this class as global pointer */ + this->engine->SetGlobalPointer(this); + + /* Scan the AI dir for scripts */ + this->ScanAIDir(); + + /* Create the dummy AI */ + this->engine->AddMethod("RegisterDummyAI", &AIInfo::DummyConstructor, 2, "tx"); + this->current_script = (char *)"%_dummy"; + this->current_dir = (char *)"%_dummy"; + extern void AI_CreateAIInfoDummy(HSQUIRRELVM vm); + AI_CreateAIInfoDummy(this->engine->GetVM()); +} + +AIScanner::~AIScanner() +{ + AIInfoList::iterator it = this->info_list.begin(); + for (; it != this->info_list.end(); it++) { + AIInfo *i = (*it).second; + delete i; + } + + delete this->engine; +} + +bool AIScanner::ImportLibrary(const char *library, const char *class_name, int version, HSQUIRRELVM vm, AIController *controller) +{ + /* Internally we store libraries as 'library.version' */ + char library_name[1024]; + snprintf(library_name, sizeof(library_name), "%s.%d", library, version); + + /* Check if the library + version exists */ + AILibraryList::iterator iter = this->library_list.find(library_name); + if (iter == this->library_list.end()) { + char error[1024]; + + /* Now see if the version doesn't exist, or the library */ + iter = this->library_list.find(library); + if (iter == this->library_list.end()) { + snprintf(error, sizeof(error), "couldn't find library '%s'", library); + } else { + snprintf(error, sizeof(error), "this AI is expecting library '%s' to be version %d, but the latest available is version %d", library, version, (*iter).second->GetVersion()); + } + sq_throwerror(vm, OTTD2FS(error)); + return false; + } + + /* Get the current table/class we belong to */ + HSQOBJECT parent; + sq_getstackobj(vm, 1, &parent); + + char fake_class[1024]; + int next_number; + /* Check if we already have this library loaded.. if so, fill fake_class + * with the class-name it is nested in */ + if (!controller->LoadedLibrary(library_name, &next_number, &fake_class[0], sizeof(fake_class))) { + /* Create a new fake internal name */ + snprintf(fake_class, sizeof(fake_class), "_internalNA%d", next_number); + + /* Load the library in a 'fake' namespace, so we can link it to the name the user requested */ + sq_pushroottable(vm); + sq_pushstring(vm, OTTD2FS(fake_class), -1); + sq_newclass(vm, SQFalse); + /* Load the library */ + if (!Squirrel::LoadScript(vm, (*iter).second->GetScriptName(), false)) { + char error[1024]; + snprintf(error, sizeof(error), "there was a compile error when importing '%s' version %d", library, version); + sq_throwerror(vm, OTTD2FS(error)); + return false; + } + /* Create the fake class */ + sq_newslot(vm, -3, SQFalse); + sq_pop(vm, 1); + + controller->AddLoadedLibrary(library_name, fake_class); + } + + /* Find the real class inside the fake class (like 'sets.Vector') */ + sq_pushroottable(vm); + sq_pushstring(vm, OTTD2FS(fake_class), -1); + if (SQ_FAILED(sq_get(vm, -2))) { + sq_throwerror(vm, _SC("internal error assigning library class")); + return false; + } + sq_pushstring(vm, OTTD2FS((*iter).second->GetInstanceName()), -1); + if (SQ_FAILED(sq_get(vm, -2))) { + char error[1024]; + snprintf(error, sizeof(error), "unable to find class '%s' in the library '%s' version %d", (*iter).second->GetInstanceName(), library, version); + sq_throwerror(vm, OTTD2FS(error)); + return false; + } + HSQOBJECT obj; + sq_getstackobj(vm, -1, &obj); + sq_pop(vm, 3); + + if (StrEmpty(class_name)) { + sq_pushobject(vm, obj); + return true; + } + + /* Now link the name the user wanted to our 'fake' class */ + sq_pushobject(vm, parent); + sq_pushstring(vm, OTTD2FS(class_name), -1); + sq_pushobject(vm, obj); + sq_newclass(vm, SQTrue); + sq_newslot(vm, -3, SQFalse); + sq_pop(vm, 1); + + sq_pushobject(vm, obj); + return true; +} + +void AIScanner::RegisterLibrary(AILibrary *library) +{ + const char *ai_name_without_version = library->GetDirName(); + char ai_name[1024]; + snprintf(ai_name, sizeof(ai_name), "%s.%d", library->GetDirName(), library->GetVersion()); + + /* Check if we register twice; than the first always wins */ + if (this->library_list.find(ai_name) != this->library_list.end()) { + /* In case they are not the same dir, give a warning */ + if (strcasecmp(library->GetScriptName(), this->library_list[ai_name]->GetScriptName()) != 0) { + DEBUG(ai, 0, "Registering two libraries with the same name"); + DEBUG(ai, 0, " 1: %s", this->library_list[ai_name]->GetScriptName()); + DEBUG(ai, 0, " 2: %s", library->GetScriptName()); + DEBUG(ai, 0, "The first is taking precedence"); + } + /* Delete the new AILibrary, as we will be using the old one */ + delete library; + return; + } + + this->library_list[strdup(ai_name)] = library; + /* Insert the global name too, so we if the library is known at all */ + if (this->library_list.find(ai_name_without_version) == this->library_list.end()) { + this->library_list[strdup(ai_name_without_version)] = library; + } else if (this->library_list[ai_name_without_version]->GetVersion() < library->GetVersion()) { + this->library_list[ai_name_without_version] = library; + } +} + +void AIScanner::RegisterAI(AIInfo *info) +{ + const char *ai_name = info->GetDirName(); + + /* Check if we register twice; than the first always wins */ + if (this->info_list.find(ai_name) != this->info_list.end()) { + /* In case they are not the same dir, give a warning */ + if (strcasecmp(info->GetScriptName(), this->info_list[ai_name]->GetScriptName()) != 0) { + DEBUG(ai, 0, "Registering two AIs with the same name"); + DEBUG(ai, 0, " 1: %s", this->info_list[ai_name]->GetScriptName()); + DEBUG(ai, 0, " 2: %s", info->GetScriptName()); + DEBUG(ai, 0, "The first is taking precedence"); + } + /* Delete the new AIInfo, as we will be using the old one */ + delete info; + return; + } + + this->info_list[strdup(ai_name)] = info; +} + +void AIScanner::UnregisterAI(AIInfo *info) +{ + this->info_list.erase(info->GetDirName()); +} + +AIInfo *AIScanner::SelectRandomAI() +{ + if (this->info_list.size() == 0) { + DEBUG(ai, 0, "No suitable AI found, loading 'dummy' AI."); + return this->info_dummy; + } + + /* Find a random AI */ + uint pos; + if (_networking) pos = InteractiveRandomRange((uint16)this->info_list.size()); + else pos = RandomRange((uint16)this->info_list.size()); + + /* Find the Nth item from the array */ + AIInfoList::iterator it = this->info_list.begin(); + for (; pos > 0; pos--) it++; + AIInfoList::iterator first_it = it; + AIInfo *i = (*it).second; + + if (!i->AllowStartup()) { + /* We can't start this AI, try to find the next best */ + do { + it++; + if (it == this->info_list.end()) it = this->info_list.begin(); + /* Back at the beginning? We can't start an AI. */ + if (first_it == it) { + DEBUG(ai, 0, "No suitable AI found, loading 'dummy' AI."); + return this->info_dummy; + } + + i = (*it).second; + } while (!i->AllowStartup()); + } + return i; +} + +AIInfo *AIScanner::FindAI(const char *name) +{ + if (this->info_list.size() == 0) return NULL; + if (name == NULL) return NULL; + + AIInfoList::iterator it = this->info_list.begin(); + for (; it != this->info_list.end(); it++) { + AIInfo *i = (*it).second; + + if (strcasecmp(name, (*it).first) == 0 && i->AllowStartup()) { + return i; + } + } + + return NULL; +} + +char *AIScanner::GetAIConsoleList(char *p, const char *last) +{ + p += seprintf(p, last, "List of AIs:\n"); + AIInfoList::iterator it = this->info_list.begin(); + for (; it != this->info_list.end(); it++) { + AIInfo *i = (*it).second; + if (!i->AllowStartup()) continue; + p += seprintf(p, last, "%10s: %s\n", (*it).first, i->GetDescription()); + } + p += seprintf(p, last, "\n"); + + return p; +} diff --git a/src/ai/ai_scanner.hpp b/src/ai/ai_scanner.hpp new file mode 100644 index 000000000..2801f556a --- /dev/null +++ b/src/ai/ai_scanner.hpp @@ -0,0 +1,102 @@ +/* $Id$ */ + +/** @file ai_scanner.hpp declarations of the class for AI scanner */ + +#ifndef AI_SCANNER_HPP +#define AI_SCANNER_HPP + +#include <map> + +class AIScanner { +public: + AIScanner(); + ~AIScanner(); + + /** + * Import a library inside the Squirrel VM. + */ + bool ImportLibrary(const char *library, const char *class_name, int version, HSQUIRRELVM vm, class AIController *controller); + + /** + * Register a library to be put in the available list. + */ + void RegisterLibrary(class AILibrary *library); + + /** + * Register an AI to be put in the available list. + */ + void RegisterAI(class AIInfo *info); + + void SetDummyAI(class AIInfo *info) { this->info_dummy = info; } + + /** + * Remove an AI from the available list. + */ + void UnregisterAI(class AIInfo *info); + + /** + * Select a Random AI. + */ + class AIInfo *SelectRandomAI(); + + /** + * Find an AI by name. + */ + class AIInfo *FindAI(const char *name); + + /** + * Get the list of available AIs for the console. + */ + char *GetAIConsoleList(char *p, const char *last); + + /** + * Get the list of all registered AIs. + */ + const AIInfoList *GetAIInfoList() { return &this->info_list; } + + /** + * Get the engine of the main squirrel handler (it indexes all avialable squirrels). + */ + class Squirrel *GetEngine() { return this->engine; } + + /** + * Get the current script the ScanDir is looking at. + */ + const char *GetCurrentScript() { return this->current_script; } + + /** + * Get the directory of the current script the ScanDir is looking at. + */ + const char *GetCurrentDirName() { return this->current_dir; } + + /** + * Rescan the AI dir for scripts. + */ + void RescanAIDir(); + +private: + typedef std::map<const char *, class AILibrary *, ltstr> AILibraryList; + + /** + * Scan the AI dir for scripts. + */ + void ScanAIDir(); + + /** + * Scan a dir for AIs. + * For non-library-scan, if an AI is found, AIInfo is created, and the AI + * is registered to the central system. + * For library-scan, if a library is found, AILibrary is created, and the + * library is registered to the central system. + */ + void ScanDir(const char *dirname, bool library_dir, char *library_depth = NULL); + + AIInfoList info_list; + AIInfo *info_dummy; + AILibraryList library_list; + class Squirrel *engine; + char *current_script; + char *current_dir; +}; + +#endif /* AI_SCANNER_HPP */ diff --git a/src/ai/ai_storage.hpp b/src/ai/ai_storage.hpp new file mode 100644 index 000000000..2e85046b4 --- /dev/null +++ b/src/ai/ai_storage.hpp @@ -0,0 +1,78 @@ +/* $Id$ */ + +/** @file ai_storage.hpp Defines AIStorage and includes all files required for it. */ + +#ifndef AI_STORAGE_HPP +#define AI_STORAGE_HPP + +#include "../command_func.h" +#include "../map_func.h" +#include "../network/network.h" +#include "../company_func.h" +#include "../signs_func.h" +#include "../tunnelbridge.h" +#include "../vehicle_func.h" +#include "../group.h" + +#include <vector> + +/** + * The callback function for Mode-classes. + */ +typedef bool (AIModeProc)(TileIndex tile, uint32 p1, uint32 p2, uint procc, CommandCost costs); + +/** + * The storage for each AI. It keeps track of important information. + */ +class AIStorage { +friend class AIObject; +private: + AIModeProc *mode; //!< The current build mode we are int. + class AIObject *mode_instance; //!< The instance belonging to the current build mode. + + uint delay; //!< The ticks of delay each DoCommand has. + bool allow_do_command; //!< Is the usage of DoCommands restricted? + + CommandCost costs; //!< The costs the AI is tracking. + Money last_cost; //!< The last cost of the command. + uint last_error; //!< The last error of the command. + bool last_command_res; //!< The last result of the command. + + VehicleID new_vehicle_id; //!< The ID of the new Vehicle. + SignID new_sign_id; //!< The ID of the new Sign. + TileIndex new_tunnel_endtile; //!< The TileIndex of the new Tunnel. + GroupID new_group_id; //!< The ID of the new Group. + + std::vector<int> callback_value; //!< The values which need to survive a callback. + + RoadType road_type; //!< The current roadtype we build. + RailType rail_type; //!< The current railtype we build. + + void *event_data; //!< Pointer to the event data storage. + void *log_data; //!< Pointer to the log data storage. + +public: + AIStorage() : + mode (NULL), + mode_instance (NULL), + delay (1), + allow_do_command (true), + /* costs (can't be set) */ + last_cost (0), + last_error (STR_NULL), + last_command_res (true), + new_vehicle_id (0), + new_sign_id (0), + new_tunnel_endtile(INVALID_TILE), + new_group_id (0), + /* calback_value (can't be set) */ + road_type (INVALID_ROADTYPE), + rail_type (INVALID_RAILTYPE), + event_data (NULL), + log_data (NULL) + { } + + ~AIStorage(); +}; + +#endif /* AI_STORAGE_HPP */ diff --git a/src/ai/api/Doxyfile b/src/ai/api/Doxyfile new file mode 100644 index 000000000..ff5d7a511 --- /dev/null +++ b/src/ai/api/Doxyfile @@ -0,0 +1,244 @@ +# Doxyfile 1.5.4 + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- +DOXYFILE_ENCODING = UTF-8 +PROJECT_NAME = "OpenTTD NoAI API " +PROJECT_NUMBER = +OUTPUT_DIRECTORY = ../../../docs/aidocs/ +CREATE_SUBDIRS = NO +OUTPUT_LANGUAGE = English +BRIEF_MEMBER_DESC = YES +REPEAT_BRIEF = YES +ABBREVIATE_BRIEF = "The $name class " \ + "The $name widget " \ + "The $name file " \ + is \ + provides \ + specifies \ + contains \ + represents \ + a \ + an \ + the +ALWAYS_DETAILED_SEC = NO +INLINE_INHERITED_MEMB = NO +FULL_PATH_NAMES = YES +STRIP_FROM_PATH = ./ +STRIP_FROM_INC_PATH = +SHORT_NAMES = NO +JAVADOC_AUTOBRIEF = YES +QT_AUTOBRIEF = NO +MULTILINE_CPP_IS_BRIEF = NO +DETAILS_AT_TOP = NO +INHERIT_DOCS = YES +SEPARATE_MEMBER_PAGES = NO +TAB_SIZE = 2 +ALIASES = +OPTIMIZE_OUTPUT_FOR_C = YES +OPTIMIZE_OUTPUT_JAVA = NO +BUILTIN_STL_SUPPORT = NO +CPP_CLI_SUPPORT = NO +SIP_SUPPORT = NO +DISTRIBUTE_GROUP_DOC = NO +SUBGROUPING = YES +TYPEDEF_HIDES_STRUCT = NO +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- +EXTRACT_ALL = NO +EXTRACT_PRIVATE = NO +EXTRACT_STATIC = YES +EXTRACT_LOCAL_CLASSES = YES +EXTRACT_LOCAL_METHODS = YES +EXTRACT_ANON_NSPACES = NO +HIDE_UNDOC_MEMBERS = NO +HIDE_UNDOC_CLASSES = NO +HIDE_FRIEND_COMPOUNDS = NO +HIDE_IN_BODY_DOCS = YES +INTERNAL_DOCS = YES +CASE_SENSE_NAMES = YES +HIDE_SCOPE_NAMES = NO +SHOW_INCLUDE_FILES = NO +INLINE_INFO = YES +SORT_MEMBER_DOCS = YES +SORT_BRIEF_DOCS = NO +SORT_BY_SCOPE_NAME = NO +GENERATE_TODOLIST = NO +GENERATE_TESTLIST = NO +GENERATE_BUGLIST = NO +GENERATE_DEPRECATEDLIST= NO +ENABLED_SECTIONS = +MAX_INITIALIZER_LINES = 30 +SHOW_USED_FILES = NO +SHOW_DIRECTORIES = NO +FILE_VERSION_FILTER = +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- +QUIET = NO +WARNINGS = YES +WARN_IF_UNDOCUMENTED = YES +WARN_IF_DOC_ERROR = YES +WARN_NO_PARAMDOC = YES +WARN_FORMAT = "$file:$line: $text " +WARN_LOGFILE = +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- +INPUT = . +INPUT_ENCODING = UTF-8 +FILE_PATTERNS = *.h \ + *.hpp +RECURSIVE = YES +EXCLUDE = +EXCLUDE_SYMLINKS = NO +EXCLUDE_PATTERNS = +EXCLUDE_SYMBOLS = GetClassName DECLARE_ENUM_AS_BIT_SET DECLARE_POSTFIX_INCREMENT +EXAMPLE_PATH = +EXAMPLE_PATTERNS = * +EXAMPLE_RECURSIVE = NO +IMAGE_PATH = +INPUT_FILTER = +FILTER_PATTERNS = +FILTER_SOURCE_FILES = NO +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- +SOURCE_BROWSER = NO +INLINE_SOURCES = NO +STRIP_CODE_COMMENTS = YES +REFERENCED_BY_RELATION = NO +REFERENCES_RELATION = NO +REFERENCES_LINK_SOURCE = YES +USE_HTAGS = NO +VERBATIM_HEADERS = NO +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- +ALPHABETICAL_INDEX = NO +COLS_IN_ALPHA_INDEX = 5 +IGNORE_PREFIX = +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- +GENERATE_HTML = YES +HTML_OUTPUT = html +HTML_FILE_EXTENSION = .html +HTML_HEADER = +HTML_FOOTER = +HTML_STYLESHEET = +HTML_ALIGN_MEMBERS = YES +GENERATE_HTMLHELP = NO +HTML_DYNAMIC_SECTIONS = NO +CHM_FILE = +HHC_LOCATION = +GENERATE_CHI = NO +BINARY_TOC = NO +TOC_EXPAND = NO +DISABLE_INDEX = NO +ENUM_VALUES_PER_LINE = 1 +GENERATE_TREEVIEW = NO +TREEVIEW_WIDTH = 250 +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- +GENERATE_LATEX = NO +LATEX_OUTPUT = latex +LATEX_CMD_NAME = latex +MAKEINDEX_CMD_NAME = makeindex +COMPACT_LATEX = NO +PAPER_TYPE = a4wide +EXTRA_PACKAGES = +LATEX_HEADER = +PDF_HYPERLINKS = NO +USE_PDFLATEX = NO +LATEX_BATCHMODE = NO +LATEX_HIDE_INDICES = NO +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- +GENERATE_RTF = NO +RTF_OUTPUT = rtf +COMPACT_RTF = NO +RTF_HYPERLINKS = NO +RTF_STYLESHEET_FILE = +RTF_EXTENSIONS_FILE = +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- +GENERATE_MAN = NO +MAN_OUTPUT = man +MAN_EXTENSION = .3 +MAN_LINKS = NO +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- +GENERATE_XML = NO +XML_OUTPUT = xml +XML_SCHEMA = +XML_DTD = +XML_PROGRAMLISTING = YES +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- +GENERATE_AUTOGEN_DEF = NO +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- +GENERATE_PERLMOD = NO +PERLMOD_LATEX = NO +PERLMOD_PRETTY = YES +PERLMOD_MAKEVAR_PREFIX = +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- +ENABLE_PREPROCESSING = YES +MACRO_EXPANSION = YES +EXPAND_ONLY_PREDEF = YES +SEARCH_INCLUDES = YES +INCLUDE_PATH = +INCLUDE_FILE_PATTERNS = +PREDEFINED = DOXYGEN_SKIP +EXPAND_AS_DEFINED = DEF_COMMAND +SKIP_FUNCTION_MACROS = YES +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- +TAGFILES = +GENERATE_TAGFILE = openttd.tag +ALLEXTERNALS = NO +EXTERNAL_GROUPS = YES +PERL_PATH = /usr/bin/perl +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- +CLASS_DIAGRAMS = YES +MSCGEN_PATH = +HIDE_UNDOC_RELATIONS = YES +HAVE_DOT = NO +CLASS_GRAPH = YES +COLLABORATION_GRAPH = YES +GROUP_GRAPHS = YES +UML_LOOK = NO +TEMPLATE_RELATIONS = NO +INCLUDE_GRAPH = YES +INCLUDED_BY_GRAPH = YES +CALL_GRAPH = NO +CALLER_GRAPH = NO +GRAPHICAL_HIERARCHY = YES +DIRECTORY_GRAPH = YES +DOT_IMAGE_FORMAT = png +DOT_PATH = +DOTFILE_DIRS = +DOT_GRAPH_MAX_NODES = 50 +MAX_DOT_GRAPH_DEPTH = 1000 +DOT_TRANSPARENT = NO +DOT_MULTI_TARGETS = NO +GENERATE_LEGEND = NO +DOT_CLEANUP = YES +#--------------------------------------------------------------------------- +# Configuration::additions related to the search engine +#--------------------------------------------------------------------------- +SEARCHENGINE = NO diff --git a/src/ai/api/ai_abstractlist.cpp b/src/ai/api/ai_abstractlist.cpp new file mode 100644 index 000000000..d447311ac --- /dev/null +++ b/src/ai/api/ai_abstractlist.cpp @@ -0,0 +1,818 @@ +/* $Id$ */ + +/** @file ai_abstractlist.cpp Implementation of AIAbstractList. */ + +#include <squirrel.h> +#include "ai_abstractlist.hpp" +#include "../../debug.h" +#include "../../core/alloc_func.hpp" + +/** + * Base class for any AIAbstractList sorter. + */ +class AIAbstractListSorter { +protected: + AIAbstractList *list; + +public: + /** + * Virtual dtor, needed to mute warnings. + */ + virtual ~AIAbstractListSorter() { } + + /** + * Get the first item of the sorter. + */ + virtual int32 Begin() = 0; + + /** + * Stop iterating a sorter. + */ + virtual void End() = 0; + + /** + * Get the next item of the sorter. + */ + virtual int32 Next() = 0; + + /** + * See if there is a next item of the sorter. + */ + virtual bool HasNext() = 0; + + /** + * Callback from the list if an item gets removed. + */ + virtual void Remove(int item) = 0; +}; + +/** + * Sort by value, ascending. + */ +class AIAbstractListSorterValueAscending : public AIAbstractListSorter { +private: + AIAbstractList::AIAbstractListBucket::iterator bucket_iter; + AIAbstractList::AIItemList *bucket_list; + AIAbstractList::AIItemList::iterator bucket_list_iter; + bool has_no_more_items; + int32 item_next; + +public: + AIAbstractListSorterValueAscending(AIAbstractList *list) + { + this->list = list; + this->End(); + } + + int32 Begin() + { + if (this->list->buckets.empty()) return 0; + this->has_no_more_items = false; + + this->bucket_iter = this->list->buckets.begin(); + this->bucket_list = &(*this->bucket_iter).second; + this->bucket_list_iter = this->bucket_list->begin(); + this->item_next = *this->bucket_list_iter; + + int32 item_current = this->item_next; + FindNext(); + return item_current; + } + + void End() + { + this->bucket_list = NULL; + this->has_no_more_items = true; + this->item_next = 0; + } + + void FindNext() + { + if (this->bucket_list == NULL) { + this->has_no_more_items = true; + return; + } + + this->bucket_list_iter++; + if (this->bucket_list_iter == this->bucket_list->end()) { + this->bucket_iter++; + if (this->bucket_iter == this->list->buckets.end()) { + this->bucket_list = NULL; + return; + } + this->bucket_list = &(*this->bucket_iter).second; + this->bucket_list_iter = this->bucket_list->begin(); + } + this->item_next = *this->bucket_list_iter; + } + + int32 Next() + { + if (!this->HasNext()) return 0; + + int32 item_current = this->item_next; + FindNext(); + return item_current; + } + + void Remove(int item) + { + if (!this->HasNext()) return; + + /* If we remove the 'next' item, skip to the next */ + if (item == this->item_next) { + FindNext(); + return; + } + } + + bool HasNext() + { + return !(this->list->buckets.empty() || this->has_no_more_items); + } +}; + +/** + * Sort by value, descending. + */ +class AIAbstractListSorterValueDescending : public AIAbstractListSorter { +private: + AIAbstractList::AIAbstractListBucket::iterator bucket_iter; + AIAbstractList::AIItemList *bucket_list; + AIAbstractList::AIItemList::iterator bucket_list_iter; + bool has_no_more_items; + int32 item_next; + +public: + AIAbstractListSorterValueDescending(AIAbstractList *list) + { + this->list = list; + this->End(); + } + + int32 Begin() + { + if (this->list->buckets.empty()) return 0; + this->has_no_more_items = false; + + /* Go to the end of the bucket-list */ + this->bucket_iter = this->list->buckets.begin(); + for (size_t i = this->list->buckets.size(); i > 1; i--) this->bucket_iter++; + this->bucket_list = &(*this->bucket_iter).second; + + /* Go to the end of the items in the bucket */ + this->bucket_list_iter = this->bucket_list->begin(); + for (size_t i = this->bucket_list->size(); i > 1; i--) this->bucket_list_iter++; + this->item_next = *this->bucket_list_iter; + + int32 item_current = this->item_next; + FindNext(); + return item_current; + } + + void End() { + this->bucket_list = NULL; + this->has_no_more_items = true; + this->item_next = 0; + } + + void FindNext() + { + if (this->bucket_list == NULL) { + this->has_no_more_items = true; + return; + } + + if (this->bucket_list_iter == this->bucket_list->begin()) { + if (this->bucket_iter == this->list->buckets.begin()) { + this->bucket_list = NULL; + return; + } + this->bucket_iter--; + this->bucket_list = &(*this->bucket_iter).second; + /* Go to the end of the items in the bucket */ + this->bucket_list_iter = this->bucket_list->begin(); + for (size_t i = this->bucket_list->size(); i > 1; i--) this->bucket_list_iter++; + } else { + this->bucket_list_iter--; + } + this->item_next = *this->bucket_list_iter; + } + + int32 Next() + { + if (!this->HasNext()) return 0; + + int32 item_current = this->item_next; + FindNext(); + return item_current; + } + + void Remove(int item) + { + if (!this->HasNext()) return; + + /* If we remove the 'next' item, skip to the next */ + if (item == this->item_next) { + FindNext(); + return; + } + } + + bool HasNext() + { + return !(this->list->buckets.empty() || this->has_no_more_items); + } +}; + +/** + * Sort by item, ascending. + */ +class AIAbstractListSorterItemAscending : public AIAbstractListSorter { +private: + AIAbstractList::AIAbstractListMap::iterator item_iter; + bool has_no_more_items; + int32 item_next; + +public: + AIAbstractListSorterItemAscending(AIAbstractList *list) + { + this->list = list; + this->End(); + } + + int32 Begin() + { + if (this->list->items.empty()) return 0; + this->has_no_more_items = false; + + this->item_iter = this->list->items.begin(); + this->item_next = (*this->item_iter).first; + + int32 item_current = this->item_next; + FindNext(); + return item_current; + } + + void End() + { + this->has_no_more_items = true; + } + + void FindNext() + { + if (this->item_iter == this->list->items.end()) { + this->has_no_more_items = true; + return; + } + this->item_iter++; + if (this->item_iter != this->list->items.end()) item_next = (*this->item_iter).first; + } + + int32 Next() + { + if (!this->HasNext()) return 0; + + int32 item_current = this->item_next; + FindNext(); + return item_current; + } + + void Remove(int item) { + if (!this->HasNext()) return; + + /* If we remove the 'next' item, skip to the next */ + if (item == this->item_next) { + FindNext(); + return; + } + } + + bool HasNext() + { + return !(this->list->items.empty() || this->has_no_more_items); + } +}; + +/** + * Sort by item, descending. + */ +class AIAbstractListSorterItemDescending : public AIAbstractListSorter { +private: + AIAbstractList::AIAbstractListMap::iterator item_iter; + bool has_no_more_items; + int32 item_next; + +public: + AIAbstractListSorterItemDescending(AIAbstractList *list) + { + this->list = list; + this->End(); + } + + int32 Begin() + { + if (this->list->items.empty()) return 0; + this->has_no_more_items = false; + + this->item_iter = this->list->items.begin(); + for (size_t i = this->list->items.size(); i > 1; i--) this->item_iter++; + this->item_next = (*this->item_iter).first; + + int32 item_current = this->item_next; + FindNext(); + return item_current; + } + + void End() + { + this->has_no_more_items = true; + } + + void FindNext() + { + if (this->item_iter == this->list->items.end()) { + this->has_no_more_items = true; + return; + } + this->item_iter--; + if (this->item_iter != this->list->items.end()) item_next = (*this->item_iter).first; + } + + int32 Next() + { + if (!this->HasNext()) return 0; + + int32 item_current = this->item_next; + FindNext(); + return item_current; + } + + void Remove(int item) + { + if (!this->HasNext()) return; + + /* If we remove the 'next' item, skip to the next */ + if (item == this->item_next) { + FindNext(); + return; + } + } + + bool HasNext() + { + return !(this->list->items.empty() || this->has_no_more_items); + } +}; + + + +AIAbstractList::AIAbstractList() +{ + /* Default sorter */ + this->sorter = new AIAbstractListSorterValueDescending(this); + this->sorter_type = SORT_BY_VALUE; + this->sort_ascending = false; + this->initialized = false; +} + +AIAbstractList::~AIAbstractList() +{ + delete this->sorter; +} + +bool AIAbstractList::HasItem(int32 item) +{ + return this->items.count(item) == 1; +} + +void AIAbstractList::Clear() +{ + this->items.clear(); + this->buckets.clear(); + this->sorter->End(); +} + +void AIAbstractList::AddItem(int32 item) +{ + if (this->HasItem(item)) return; + + this->items[item] = 0; + this->buckets[0].insert(item); +} + +void AIAbstractList::RemoveItem(int32 item) +{ + if (!this->HasItem(item)) return; + + int32 value = this->GetValue(item); + + this->sorter->Remove(item); + this->buckets[value].erase(item); + if (this->buckets[value].empty()) this->buckets.erase(value); + this->items.erase(item); +} + +int32 AIAbstractList::Begin() +{ + this->initialized = true; + return this->sorter->Begin(); +} + +int32 AIAbstractList::Next() +{ + if (this->initialized == false) { + DEBUG(ai, 0, "ERROR: Next() is invalid as Begin() is never called"); + return false; + } + return this->sorter->Next(); +} + +bool AIAbstractList::IsEmpty() +{ + return this->items.empty(); +} + +bool AIAbstractList::HasNext() +{ + if (this->initialized == false) { + DEBUG(ai, 0, "ERROR: HasNext() is invalid as Begin() is never called"); + return false; + } + return this->sorter->HasNext(); +} + +int32 AIAbstractList::Count() +{ + return (int32)this->items.size(); +} + +int32 AIAbstractList::GetValue(int32 item) +{ + if (!this->HasItem(item)) return 0; + + return this->items[item]; +} + +bool AIAbstractList::SetValue(int32 item, int32 value) +{ + if (!this->HasItem(item)) return false; + + int32 value_old = this->GetValue(item); + + this->sorter->Remove(item); + this->buckets[value_old].erase(item); + if (this->buckets[value_old].empty()) this->buckets.erase(value_old); + this->items[item] = value; + this->buckets[value].insert(item); + + return true; +} + +void AIAbstractList::Sort(SorterType sorter, bool ascending) +{ + if (sorter != SORT_BY_VALUE && sorter != SORT_BY_ITEM) return; + if (sorter == this->sorter_type && ascending == this->sort_ascending) return; + + delete this->sorter; + switch (sorter) { + case SORT_BY_ITEM: + if (ascending) this->sorter = new AIAbstractListSorterItemAscending(this); + else this->sorter = new AIAbstractListSorterItemDescending(this); + break; + + case SORT_BY_VALUE: + if (ascending) this->sorter = new AIAbstractListSorterValueAscending(this); + else this->sorter = new AIAbstractListSorterValueDescending(this); + break; + + default: + this->Sort(SORT_BY_ITEM, false); + return; + } + this->sorter_type = sorter; + this->sort_ascending = ascending; +} + +void AIAbstractList::AddList(AIAbstractList *list) +{ + AIAbstractListMap *list_items = &list->items; + for (AIAbstractListMap::iterator iter = list_items->begin(); iter != list_items->end(); iter++) { + this->AddItem((*iter).first); + this->SetValue((*iter).first, (*iter).second); + } +} + +void AIAbstractList::RemoveAboveValue(int32 value) +{ + for (AIAbstractListMap::iterator next_iter, iter = this->items.begin(); iter != this->items.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).second > value) this->items.erase(iter); + } + + for (AIAbstractListBucket::iterator next_iter, iter = this->buckets.begin(); iter != this->buckets.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).first > value) this->buckets.erase(iter); + } +} + +void AIAbstractList::RemoveBelowValue(int32 value) +{ + for (AIAbstractListMap::iterator next_iter, iter = this->items.begin(); iter != this->items.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).second < value) this->items.erase(iter); + } + + for (AIAbstractListBucket::iterator next_iter, iter = this->buckets.begin(); iter != this->buckets.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).first < value) this->buckets.erase(iter); + } +} + +void AIAbstractList::RemoveBetweenValue(int32 start, int32 end) +{ + for (AIAbstractListMap::iterator next_iter, iter = this->items.begin(); iter != this->items.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).second > start && (*iter).second < end) this->items.erase(iter); + } + + for (AIAbstractListBucket::iterator next_iter, iter = this->buckets.begin(); iter != this->buckets.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).first > start && (*iter).first < end) this->buckets.erase(iter); + } +} + +void AIAbstractList::RemoveValue(int32 value) +{ + for (AIAbstractListMap::iterator next_iter, iter = this->items.begin(); iter != this->items.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).second == value) this->items.erase(iter); + } + + for (AIAbstractListBucket::iterator next_iter, iter = this->buckets.begin(); iter != this->buckets.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).first == value) this->buckets.erase(iter); + } +} + +void AIAbstractList::RemoveTop(int32 count) +{ + if (!this->sort_ascending) { + this->Sort(this->sorter_type, !this->sort_ascending); + this->RemoveBottom(count); + this->Sort(this->sorter_type, !this->sort_ascending); + return; + } + + switch (this->sorter_type) { + default: NOT_REACHED(); + case SORT_BY_VALUE: + for (AIAbstractListBucket::iterator iter = this->buckets.begin(); iter != this->buckets.end(); iter = this->buckets.begin()) { + AIItemList *items = &(*iter).second; + size_t size = items->size(); + for (AIItemList::iterator iter = items->begin(); iter != items->end(); iter = items->begin()) { + if (--count < 0) return; + this->RemoveItem(*iter); + /* When the last item is removed from the bucket, the bucket itself is removed. + * This means that the iterators can be invalid after a call to RemoveItem. + */ + if (--size == 0) break; + } + } + break; + + case SORT_BY_ITEM: + for (AIAbstractListMap::iterator iter = this->items.begin(); iter != this->items.end(); iter = this->items.begin()) { + if (--count < 0) return; + this->RemoveItem((*iter).first); + } + break; + } +} + +void AIAbstractList::RemoveBottom(int32 count) +{ + if (!this->sort_ascending) { + this->Sort(this->sorter_type, !this->sort_ascending); + this->RemoveTop(count); + this->Sort(this->sorter_type, !this->sort_ascending); + return; + } + + switch (this->sorter_type) { + default: NOT_REACHED(); + case SORT_BY_VALUE: + for (AIAbstractListBucket::reverse_iterator iter = this->buckets.rbegin(); iter != this->buckets.rend(); iter = this->buckets.rbegin()) { + AIItemList *items = &(*iter).second; + size_t size = items->size(); + for (AIItemList::reverse_iterator iter = items->rbegin(); iter != items->rend(); iter = items->rbegin()) { + if (--count < 0) return; + this->RemoveItem(*iter); + /* When the last item is removed from the bucket, the bucket itself is removed. + * This means that the iterators can be invalid after a call to RemoveItem. + */ + if (--size == 0) break; + } + } + + case SORT_BY_ITEM: + for (AIAbstractListMap::reverse_iterator iter = this->items.rbegin(); iter != this->items.rend(); iter = this->items.rbegin()) { + if (--count < 0) return; + this->RemoveItem((*iter).first); + } + break; + } +} + +void AIAbstractList::RemoveList(AIAbstractList *list) +{ + AIAbstractListMap *list_items = &list->items; + for (AIAbstractListMap::iterator iter = list_items->begin(); iter != list_items->end(); iter++) { + this->RemoveItem((*iter).first); + } +} + +void AIAbstractList::KeepAboveValue(int32 value) +{ + for (AIAbstractListMap::iterator next_iter, iter = this->items.begin(); iter != this->items.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).second <= value) this->items.erase(iter); + } + + for (AIAbstractListBucket::iterator next_iter, iter = this->buckets.begin(); iter != this->buckets.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).first <= value) this->buckets.erase(iter); + } +} + +void AIAbstractList::KeepBelowValue(int32 value) +{ + for (AIAbstractListMap::iterator next_iter, iter = this->items.begin(); iter != this->items.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).second >= value) this->items.erase(iter); + } + + for (AIAbstractListBucket::iterator next_iter, iter = this->buckets.begin(); iter != this->buckets.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).first >= value) this->buckets.erase(iter); + } +} + +void AIAbstractList::KeepBetweenValue(int32 start, int32 end) +{ + for (AIAbstractListMap::iterator next_iter, iter = this->items.begin(); iter != this->items.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).second <= start || (*iter).second >= end) this->items.erase(iter); + } + + for (AIAbstractListBucket::iterator next_iter, iter = this->buckets.begin(); iter != this->buckets.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).first <= start || (*iter).first >= end) this->buckets.erase(iter); + } +} + +void AIAbstractList::KeepValue(int32 value) +{ + for (AIAbstractListMap::iterator next_iter, iter = this->items.begin(); iter != this->items.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).second != value) this->items.erase(iter); + } + + for (AIAbstractListBucket::iterator next_iter, iter = this->buckets.begin(); iter != this->buckets.end(); iter = next_iter) { + next_iter = iter; next_iter++; + if ((*iter).first != value) this->buckets.erase(iter); + } +} + +void AIAbstractList::KeepTop(int32 count) +{ + this->RemoveBottom(this->Count() - count); +} + +void AIAbstractList::KeepBottom(int32 count) +{ + this->RemoveTop(this->Count() - count); +} + +void AIAbstractList::KeepList(AIAbstractList *list) +{ + AIAbstractList tmp; + for (AIAbstractListMap::iterator iter = this->items.begin(); iter != this->items.end(); iter++) { + tmp.AddItem((*iter).first); + tmp.SetValue((*iter).first, (*iter).second); + } + + tmp.RemoveList(list); + this->RemoveList(&tmp); +} + +SQInteger AIAbstractList::_get(HSQUIRRELVM vm) { + if (sq_gettype(vm, 2) != OT_INTEGER) return SQ_ERROR; + + SQInteger idx; + sq_getinteger(vm, 2, &idx); + + if (!this->HasItem(idx)) return SQ_ERROR; + + sq_pushinteger(vm, this->GetValue(idx)); + return 1; +} + +SQInteger AIAbstractList::_nexti(HSQUIRRELVM vm) { + if (sq_gettype(vm, 2) == OT_NULL) { + if (this->IsEmpty()) { + sq_pushnull(vm); + return 1; + } + sq_pushinteger(vm, this->Begin()); + return 1; + } + + SQInteger idx; + sq_getinteger(vm, 2, &idx); + + int val = this->Next(); + if (!this->HasNext()) { + sq_pushnull(vm); + return 1; + } + + sq_pushinteger(vm, val); + return 1; +} + +SQInteger AIAbstractList::Valuate(HSQUIRRELVM vm) { + int nparam = sq_gettop(vm) - 2; + + /* Get the list instance and the function to call */ + HSQOBJECT obj_list, obj_func; + sq_getstackobj(vm, 1, &obj_list); + sq_getstackobj(vm, 2, &obj_func); + + if (sq_isclass(obj_list)) { + return sq_throwerror(vm, _SC("parameter 1 has an invalid type (expected instance)")); + } + if (sq_isfunction(obj_func)) { + return sq_throwerror(vm, _SC("parameter 2 has an invalid type (expected function)")); + } + + sq_addref(vm, &obj_func); + + /* Read the params */ + HSQOBJECT *obj_params = AllocaM(HSQOBJECT, nparam); + for (int i = 0; i < nparam; i++) { + sq_getstackobj(vm, i + 3, &obj_params[i]); + sq_addref(vm, &obj_params[i]); + } + /* Remove all unneeded stuff */ + sq_pop(vm, nparam + 1); + + /* Walk all items, and query the result */ + this->buckets.clear(); + for (AIAbstractListMap::iterator iter = this->items.begin(); iter != this->items.end(); iter++) { + /* The function to call */ + sq_pushobject(vm, obj_func); + /* The 'list' instance; this is most likely wrong, but we need to send something ;) */ + sq_pushobject(vm, obj_list); + + /* Now send the params */ + sq_pushinteger(vm, (*iter).first); + for (int i = 0; i < nparam; i++) { + sq_pushobject(vm, obj_params[i]); + } + + /* Call the function */ + if (SQ_FAILED(sq_call(vm, nparam + 2, SQTrue, SQTrue))) return SQ_ERROR; + + /* Retreive the return value */ + SQInteger value; + switch (sq_gettype(vm, -1)) { + case OT_INTEGER: { + sq_getinteger(vm, -1, &value); + } break; + + case OT_BOOL: { + SQBool v; + sq_getbool(vm, -1, &v); + value = v ? 1 : 0; + } break; + + default: { + sq_pop(vm, 3); + sq_release(vm, &obj_func); + for (int i = 0; i < nparam; i++) sq_release(vm, &obj_params[i]); + + return sq_throwerror(vm, _SC("return value of valuator is not valid (not integer/bool)")); + } + } + /* Remove junk */ + sq_pop(vm, 2); + + (*iter).second = (int32)value; + this->buckets[(int32)value].insert((*iter).first); + } + + sq_release(vm, &obj_func); + for (int i = 0; i < nparam; i++) sq_release(vm, &obj_params[i]); + return 0; +} diff --git a/src/ai/api/ai_abstractlist.hpp b/src/ai/api/ai_abstractlist.hpp new file mode 100644 index 000000000..55a4559f8 --- /dev/null +++ b/src/ai/api/ai_abstractlist.hpp @@ -0,0 +1,263 @@ +/* $Id$ */ + +/** @file ai_abstractlist.hpp A list which can keep item/value pairs, which you can walk. */ +/** @defgroup AIList Classes that create a list of items. */ + +#ifndef AI_ABSTRACTLIST_HPP +#define AI_ABSTRACTLIST_HPP + +#include "ai_object.hpp" +#include <map> +#include <set> + +class AIAbstractListSorter; + +/** + * Class that creates a list which can keep item/value pairs, which you can walk. + */ +class AIAbstractList : public AIObject { +public: + static const char *GetClassName() { return "AIAbstractList"; } + + /** Type of sorter */ + enum SorterType { + SORT_BY_VALUE, ///< Sort the list based on the value of the item. + SORT_BY_ITEM, ///< Sort the list based on the item itself. + }; + +private: + AIAbstractListSorter *sorter; + SorterType sorter_type; + bool sort_ascending; + bool initialized; + +public: + typedef std::set<int32> AIItemList; //!< The list of items inside the bucket + typedef std::map<int32, AIItemList> AIAbstractListBucket; //!< The bucket list per value + typedef std::map<int32, int32> AIAbstractListMap; //!< List per item + + AIAbstractListMap items; //!< The items in the list + AIAbstractListBucket buckets; //!< The items in the list, sorted by value + +protected: + /** + * Add a single item to the list. + * @param item the item to add. Should be unique, otherwise it is ignored. + * @note the value is set to 0 by default. + */ + void AddItem(int32 item); + + /** + * Remove a single item from the list. + * @param item the item to remove. If not existing, it is ignored. + */ + void RemoveItem(int32 item); + +public: + AIAbstractList(); + ~AIAbstractList(); + + /** + * Clear the list, making Count() returning 0 and IsEmpty() returning true. + */ + void Clear(); + + /** + * Check if an item is in the list. + * @param item the item to check for. + * @return true if the item is in the list. + */ + bool HasItem(int32 item); + + /** + * Go to the beginning of the list. + * @return the item value of the first item. + */ + int32 Begin(); + + /** + * Go to the next item in the list. + * @return the item value of the next item. + * @note returns 0 if beyond end-of-list. Use HasNext() to check for end-of-list. + */ + int32 Next(); + + /** + * Check if a list is empty. + * @return true if the list is empty. + */ + bool IsEmpty(); + + /** + * Check if there is a next element. In other words, if this is true, + * Next() will return a valid item. + * @return true if there is a next item. + */ + bool HasNext(); + + /** + * Returns the amount of items in the list. + * @return amount of items in the list. + */ + int32 Count(); + + /** + * Get the value that belongs to this item. + * @param item the item to get the value from + * @return the value that belongs to this item. + */ + int32 GetValue(int32 item); + + /** + * Set a value of an item directly. + * @param item the item to set the value for. + * @param value the value to give to the item + * @return true if we could set the item to value, false otherwise. + * @note Changing values of items while looping through a list might cause + * entries to be skipped. Be very careful with such operations. + */ + bool SetValue(int32 item, int32 value); + + /** + * Sort this list by the given sorter and direction. + * @param sorter the type of sorter to use + * @param ascending if true, lowest value is on top, else at bottom. + * @note the current item stays at the same place. + */ + void Sort(SorterType sorter, bool ascending); + + /** + * Add one list to an other one. + * @param list The list that will be added to the caller. + * @post The list to be added ('list') stays unmodified. + * @note All added items keep their value as it was in 'list'. + * @note If the item already exists inside the caller, the value of the + * list that is added is set on the item. + */ + void AddList(AIAbstractList *list); + + /** + * Removes all items with a higher value than 'value'. + * @param value the value above which all items are removed. + */ + void RemoveAboveValue(int32 value); + + /** + * Removes all items with a lower value than 'value'. + * @param value the value below which all items are removed. + */ + void RemoveBelowValue(int32 value); + + /** + * Removes all items with a value above start and below end. + * @param start the lower bound of the to be removed values (exclusive). + * @param end the upper bound of the to be removed valuens (exclusive). + */ + void RemoveBetweenValue(int32 start, int32 end); + + /** + * Remove all items with this value. + * @param value the value to remove. + */ + void RemoveValue(int32 value); + + /** + * Remove the first count items. + * @param count the amount of items to remove. + */ + void RemoveTop(int32 count); + + /** + * Remove the last count items. + * @param count the amount of items to remove. + */ + void RemoveBottom(int32 count); + + /** + * Remove everything that is in the given list from this list (same item index that is). + * @param list the list of items to remove. + * @pre list != NULL + */ + void RemoveList(AIAbstractList *list); + + /** + * Keep all items with a higher value than 'value'. + * @param value the value above which all items are kept. + */ + void KeepAboveValue(int32 value); + + /** + * Keep all items with a lower value than 'value'. + * @param value the value below which all items are kept. + */ + void KeepBelowValue(int32 value); + + /** + * Keep all items with a value above start and below end. + * @param start the lower bound of the to be kept values (exclusive). + * @param end the upper bound of the to be kept values (exclusive). + */ + void KeepBetweenValue(int32 start, int32 end); + + /** + * Keep all items with this value. + * @param value the value to keep. + **/ + void KeepValue(int32 value); + + /** + * Keep the first count items, i.e. remove everything except the first count items. + * @param count the amount of items to keep. + */ + void KeepTop(int32 count); + + /** + * Keep the last count items, i.e. remove everything except the last count items. + * @param count the amount of items to keep. + */ + void KeepBottom(int32 count); + + /** + * Keeps everything that is in the given list from this list (same item index that is). + * @param list the list of items to keep. + * @pre list != NULL + */ + void KeepList(AIAbstractList *list); + +#ifndef DOXYGEN_SKIP + /** + * Used for 'foreach()' and [] get from Squirrel. + */ + SQInteger _get(HSQUIRRELVM vm); + + /** + * Used for 'foreach()' from Squirrel. + */ + SQInteger _nexti(HSQUIRRELVM vm); + + /** + * The Valuate() wrapper from Squirrel. + */ + SQInteger Valuate(HSQUIRRELVM vm); +#else + /** + * Give all items a value defined by the valuator you give. + * @param valuator_function The function which will be doing the valuation. + * @param params The params to give to the valuators (minus the first param, + * which is always the index-value we are valuating). + * @note You can write your own valuators and use them. Just remember that + * the first parameter should be the index-value, and it should return + * an integer. + * @note Example: + * list.Valuate(AIBridge.GetPrice, 5); + * list.Valuate(AIBridge.GetMaxLength); + * function MyVal(bridge_id, myparam) { + * return myparam * bridge_id; // This is silly + * } + * list.Valuate(MyVal, 12); + */ + void Valuate(void *valuator_function, int params, ...); +#endif /* DOXYGEN_SKIP */ +}; + +#endif /* AI_LIST_HPP */ diff --git a/src/ai/api/ai_abstractlist.hpp.sq b/src/ai/api/ai_abstractlist.hpp.sq new file mode 100644 index 000000000..25d9f3904 --- /dev/null +++ b/src/ai/api/ai_abstractlist.hpp.sq @@ -0,0 +1,59 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_abstractlist.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIAbstractList::SorterType GetParam(ForceType<AIAbstractList::SorterType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIAbstractList::SorterType)tmp; } + template <> int Return<AIAbstractList::SorterType>(HSQUIRRELVM vm, AIAbstractList::SorterType res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIAbstractList to be used as Squirrel parameter */ + template <> AIAbstractList *GetParam(ForceType<AIAbstractList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIAbstractList *)instance; } + template <> AIAbstractList &GetParam(ForceType<AIAbstractList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAbstractList *)instance; } + template <> const AIAbstractList *GetParam(ForceType<const AIAbstractList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIAbstractList *)instance; } + template <> const AIAbstractList &GetParam(ForceType<const AIAbstractList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAbstractList *)instance; } + template <> int Return<AIAbstractList *>(HSQUIRRELVM vm, AIAbstractList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAbstractList", res, NULL, DefSQDestructorCallback<AIAbstractList>); return 1; } +}; // namespace SQConvert + +void SQAIAbstractList_Register(Squirrel *engine) { + DefSQClass <AIAbstractList> SQAIAbstractList("AIAbstractList"); + SQAIAbstractList.PreRegister(engine); + SQAIAbstractList.AddConstructor<void (AIAbstractList::*)(), 1>(engine, "x"); + + SQAIAbstractList.DefSQConst(engine, AIAbstractList::SORT_BY_VALUE, "SORT_BY_VALUE"); + SQAIAbstractList.DefSQConst(engine, AIAbstractList::SORT_BY_ITEM, "SORT_BY_ITEM"); + + SQAIAbstractList.DefSQStaticMethod(engine, &AIAbstractList::GetClassName, "GetClassName", 1, "x"); + + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Clear, "Clear", 1, "x"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::HasItem, "HasItem", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Begin, "Begin", 1, "x"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Next, "Next", 1, "x"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::IsEmpty, "IsEmpty", 1, "x"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::HasNext, "HasNext", 1, "x"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Count, "Count", 1, "x"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::GetValue, "GetValue", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::SetValue, "SetValue", 3, "xii"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Sort, "Sort", 3, "xib"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::AddList, "AddList", 2, "xx"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveAboveValue, "RemoveAboveValue", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveBelowValue, "RemoveBelowValue", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveBetweenValue, "RemoveBetweenValue", 3, "xii"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveValue, "RemoveValue", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveTop, "RemoveTop", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveBottom, "RemoveBottom", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveList, "RemoveList", 2, "xx"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepAboveValue, "KeepAboveValue", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepBelowValue, "KeepBelowValue", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepBetweenValue, "KeepBetweenValue", 3, "xii"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepValue, "KeepValue", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepTop, "KeepTop", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepBottom, "KeepBottom", 2, "xi"); + SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepList, "KeepList", 2, "xx"); + SQAIAbstractList.DefSQAdvancedMethod(engine, &AIAbstractList::_get, "_get"); + SQAIAbstractList.DefSQAdvancedMethod(engine, &AIAbstractList::_nexti, "_nexti"); + SQAIAbstractList.DefSQAdvancedMethod(engine, &AIAbstractList::Valuate, "Valuate"); + + SQAIAbstractList.PostRegister(engine); +} diff --git a/src/ai/api/ai_accounting.cpp b/src/ai/api/ai_accounting.cpp new file mode 100644 index 000000000..2134d39b0 --- /dev/null +++ b/src/ai/api/ai_accounting.cpp @@ -0,0 +1,26 @@ +/* $Id$ */ + +/** @file ai_accounting.cpp Implementation of AIAccounting. */ + +#include "ai_accounting.hpp" + +Money AIAccounting::GetCosts() +{ + return this->GetDoCommandCosts(); +} + +void AIAccounting::ResetCosts() +{ + this->SetDoCommandCosts(0); +} + +AIAccounting::AIAccounting() +{ + this->last_costs = this->GetDoCommandCosts(); + this->SetDoCommandCosts(0); +} + +AIAccounting::~AIAccounting() +{ + this->SetDoCommandCosts(this->last_costs); +} diff --git a/src/ai/api/ai_accounting.hpp b/src/ai/api/ai_accounting.hpp new file mode 100644 index 000000000..bffa051f1 --- /dev/null +++ b/src/ai/api/ai_accounting.hpp @@ -0,0 +1,54 @@ +/* $Id$ */ + +/** @file ai_accounting.hpp Everything to handle AI accounting things. */ + +#ifndef AI_ACCOUNTING_HPP +#define AI_ACCOUNTING_HPP + +#include "ai_object.hpp" + +/** + * Class that keeps track of the costs, so you can request how much a block of + * commands did cost in total. Works in both Execute as in Test mode. + * Example: + * { + * local costs = AIAccounting(); + * BuildRoad(from_here, to_here); + * BuildRoad(from_there, to_there); + * print("Costs for route is: " + costs.GetCosts()); + * } + */ +class AIAccounting : public AIObject { +public: + static const char *GetClassName() { return "AIAccounting"; } + + /** + * Creating instance of this class starts counting the costs of commands + * from zero. + * @note when the instance is destroyed, he restores the costs that was + * current when the instance was created! + */ + AIAccounting(); + + /** + * Destroying this instance reset the costs to the value it was + * in when the instance was created. + */ + ~AIAccounting(); + + /** + * Get the current value of the costs. + * @return The current costs. + */ + Money GetCosts(); + + /** + * Reset the costs to zero. + */ + void ResetCosts(); + +private: + Money last_costs; +}; + +#endif /* AI_ACCOUNTING_HPP */ diff --git a/src/ai/api/ai_accounting.hpp.sq b/src/ai/api/ai_accounting.hpp.sq new file mode 100644 index 000000000..18922b24c --- /dev/null +++ b/src/ai/api/ai_accounting.hpp.sq @@ -0,0 +1,26 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_accounting.hpp" + +namespace SQConvert { + /* Allow AIAccounting to be used as Squirrel parameter */ + template <> AIAccounting *GetParam(ForceType<AIAccounting *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIAccounting *)instance; } + template <> AIAccounting &GetParam(ForceType<AIAccounting &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAccounting *)instance; } + template <> const AIAccounting *GetParam(ForceType<const AIAccounting *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIAccounting *)instance; } + template <> const AIAccounting &GetParam(ForceType<const AIAccounting &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAccounting *)instance; } + template <> int Return<AIAccounting *>(HSQUIRRELVM vm, AIAccounting *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAccounting", res, NULL, DefSQDestructorCallback<AIAccounting>); return 1; } +}; // namespace SQConvert + +void SQAIAccounting_Register(Squirrel *engine) { + DefSQClass <AIAccounting> SQAIAccounting("AIAccounting"); + SQAIAccounting.PreRegister(engine); + SQAIAccounting.AddConstructor<void (AIAccounting::*)(), 1>(engine, "x"); + + SQAIAccounting.DefSQStaticMethod(engine, &AIAccounting::GetClassName, "GetClassName", 1, "x"); + + SQAIAccounting.DefSQMethod(engine, &AIAccounting::GetCosts, "GetCosts", 1, "x"); + SQAIAccounting.DefSQMethod(engine, &AIAccounting::ResetCosts, "ResetCosts", 1, "x"); + + SQAIAccounting.PostRegister(engine); +} diff --git a/src/ai/api/ai_airport.cpp b/src/ai/api/ai_airport.cpp new file mode 100644 index 000000000..3e435d7bc --- /dev/null +++ b/src/ai/api/ai_airport.cpp @@ -0,0 +1,130 @@ +/* $Id$ */ + +/** @file ai_airport.cpp Implementation of AIAirport. */ + +#include "ai_airport.hpp" +#include "ai_station.hpp" +#include "ai_error.hpp" +#include "../../openttd.h" +#include "../../variables.h" +#include "../../station_map.h" +#include "../../company_func.h" +#include "../../settings_type.h" +#include "../../command_type.h" +#include "../../town.h" + +/* static */ bool AIAirport::IsValidAirportType(AirportType type) +{ + return type >= AT_SMALL && type <= AT_HELISTATION; +} + +/* static */ bool AIAirport::IsHangarTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_STATION) && ::IsHangar(tile); +} + +/* static */ bool AIAirport::IsAirportTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_STATION) && ::IsAirport(tile); +} + +/* static */ bool AIAirport::AirportAvailable(AirportType type) +{ + if (!IsValidAirportType(type)) return false; + + return HasBit(::GetValidAirports(), type); +} + +/* static */ int32 AIAirport::GetAirportWidth(AirportType type) +{ + if (!IsValidAirportType(type)) return -1; + + return ::GetAirport(type)->size_x; +} + +/* static */ int32 AIAirport::GetAirportHeight(AirportType type) +{ + if (!IsValidAirportType(type)) return -1; + + return ::GetAirport(type)->size_y; +} + +/* static */ int32 AIAirport::GetAirportCoverageRadius(AirportType type) +{ + if (!IsValidAirportType(type)) return -1; + + return _settings_game.station.modified_catchment ? ::GetAirport(type)->catchment : (uint)CA_UNMODIFIED; +} + +/* static */ bool AIAirport::BuildAirport(TileIndex tile, AirportType type, bool join_adjacent) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, IsValidAirportType(type)); + + return AIObject::DoCommand(tile, type, (INVALID_STATION << 16) | (join_adjacent ? 0 : 1), CMD_BUILD_AIRPORT); +} + +/* static */ bool AIAirport::RemoveAirport(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)) + EnforcePrecondition(false, IsAirportTile(tile) || IsHangarTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR); +} + +/* static */ int32 AIAirport::GetNumHangars(TileIndex tile) +{ + if (!::IsValidTile(tile)) return -1; + if (!::IsTileType(tile, MP_STATION)) return -1; + + const Station *st = ::GetStationByTile(tile); + if (st->owner != _current_company) return -1; + if ((st->facilities & FACIL_AIRPORT) == 0) return -1; + + return st->Airport()->nof_depots; +} + +/* static */ TileIndex AIAirport::GetHangarOfAirport(TileIndex tile) +{ + if (!::IsValidTile(tile)) return INVALID_TILE; + if (!::IsTileType(tile, MP_STATION)) return INVALID_TILE; + if (GetNumHangars(tile) < 1) return INVALID_TILE; + + const Station *st = ::GetStationByTile(tile); + if (st->owner != _current_company) return INVALID_TILE; + if ((st->facilities & FACIL_AIRPORT) == 0) return INVALID_TILE; + + return ::ToTileIndexDiff(st->Airport()->airport_depots[0]) + st->xy; +} + +/* static */ AIAirport::AirportType AIAirport::GetAirportType(TileIndex tile) +{ + if (!AITile::IsStationTile(tile)) return AT_INVALID; + + StationID station_id = ::GetStationIndex(tile); + + if (!AIStation::HasStationType(station_id, AIStation::STATION_AIRPORT)) return AT_INVALID; + + return (AirportType)::GetStation(station_id)->airport_type; +} + + +/* static */ int AIAirport::GetNoiseLevelIncrease(TileIndex tile, AirportType type) +{ + extern uint8 GetAirportNoiseLevelForTown(const AirportFTAClass *afc, TileIndex town_tile, TileIndex tile); + + if (!::IsValidTile(tile)) return -1; + if (!IsValidAirportType(type)) return -1; + + if (_settings_game.economy.station_noise_level) { + const AirportFTAClass *afc = ::GetAirport(type); + const Town *t = ::ClosestTownFromTile(tile, UINT_MAX); + return GetAirportNoiseLevelForTown(afc, t->xy, tile); + } + + return 1; +} diff --git a/src/ai/api/ai_airport.hpp b/src/ai/api/ai_airport.hpp new file mode 100644 index 000000000..d1d18714b --- /dev/null +++ b/src/ai/api/ai_airport.hpp @@ -0,0 +1,164 @@ +/* $Id$ */ + +/** @file ai_airport.hpp Everything to query and build airports. */ + +#ifndef AI_AIRPORT_HPP +#define AI_AIRPORT_HPP + +#include "ai_object.hpp" + +/** + * Class that handles all airport related functions. + */ +class AIAirport : public AIObject { +public: + static const char *GetClassName() { return "AIAirport"; } + + /** + * The types of airports available in the game. + */ + enum AirportType { + /* Note: the values _are_ important as they represent an in-game value */ + AT_SMALL = 0, //!< The small airport. + AT_LARGE = 1, //!< The large airport. + AT_METROPOLITAN = 3, //!< The metropolitan airport. + AT_INTERNATIONAL = 4, //!< The international airport. + AT_COMMUTER = 5, //!< The commuter airport. + AT_INTERCON = 7, //!< The intercontinental airport. + + /* Next are the airports which only have helicopter platforms */ + AT_HELIPORT = 2, //!< The heliport. + AT_HELISTATION = 8, //!< The helistation. + AT_HELIDEPOT = 6, //!< The helidepot. + + AT_INVALID = 255, //!< Invalid airport. + }; + + /** + * All plane types available. + */ + enum PlaneType { + /* Note: the values _are_ important as they represent an in-game value */ + PT_HELICOPTER = 0, //!< A helicopter. + PT_SMALL_PLANE = 1, //!< A small plane. + PT_BIG_PLANE = 3, //!< A big plane. + + PT_INVALID = -1, //!< An invalid PlaneType + }; + + /** + * Checks whether the given AirportType is valid. + * @param type The AirportType to check. + * @return True if and only if the AirportTypeis valid. + */ + static bool IsValidAirportType(AirportType type); + + /** + * Checks whether the given tile is actually a tile with a hangar. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a hangar. + */ + static bool IsHangarTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a airport. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a airport. + */ + static bool IsAirportTile(TileIndex tile); + + /** + * Check if a certain airport type is already available. + * @param type The type of airport to check. + */ + static bool AirportAvailable(AirportType type); + + /** + * Get the width of this type of airport. + * @param type The type of airport. + * @return The width in tiles. + */ + static int32 GetAirportWidth(AirportType type); + + /** + * Get the height of this type of airport. + * @param type The type of airport. + * @return The height in tiles. + */ + static int32 GetAirportHeight(AirportType type); + + /** + * Get the coverage radius of this type of airport. + * @param type The type of airport. + * @return The radius in tiles. + */ + static int32 GetAirportCoverageRadius(AirportType type); + + /** + * Get the number of hangars of the airport. + * @param tile Any tile of the airport. + * @pre AIMap::IsValidTile(tile). + * @return The number of hangars of the airport. + */ + static int32 GetNumHangars(TileIndex tile); + + /** + * Get the first hanger tile of the airport. + * @param tile Any tile of the airport. + * @pre AIMap::IsValidTile(tile). + * @pre GetNumHangars(tile) > 0. + * @return The first hanger tile of the airport. + * @note Possible there are more hangars, but you won't be able to find them + * without walking over all the tiles of the airport and using + * IsHangarTile() on them. + */ + static TileIndex GetHangarOfAirport(TileIndex tile); + + /** + * Builds a airport with tile at the topleft corner. + * @param tile The topleft corner of the airport. + * @param type The type of airport to build. + * @param join_adjacent When building next to an other station, don't create a new station when this flag is true. + * @pre AIMap::IsValidTile(tile). + * @pre AirportAvailable(type). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_FLAT_LAND_REQUIRED + * @exception AIError::ERR_LOCAL_AUTHORITY_REFUSES + * @exception AIStation::ERR_STATION_TOO_LARGE + * @exception AIStation::ERR_STATION_TOO_CLOSE_TO_OTHER_STATION + * @return Whether the airport has been/can be build or not. + */ + static bool BuildAirport(TileIndex tile, AirportType type, bool join_adjacent); + + /** + * Removes a airport. + * @param tile Any tile of the airport. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return Whether the airport has been/can be removed or not. + */ + static bool RemoveAirport(TileIndex tile); + + /** + * Get the AirportType of an existing airport. + * @param tile Any tile of the airport. + * @pre AITile::IsStationTile(tile). + * @pre AIStation::HasStationType(AIStation.GetStationID(tile), AIStation::STATION_AIRPORT). + * @return The AirportType of the airport. + */ + static AirportType GetAirportType(TileIndex tile); + + /** + * Get the noise that will be added to the nearest town if an airport was + * built at this tile. + * @param tile The tile to check. + * @param type The AirportType to check. + * @return The TownID of the town closest to the tile. + * @note The noise will be added to the town with TownID AITile.GetClosestTown(tile). + */ + static int GetNoiseLevelIncrease(TileIndex tile, AirportType type); +}; + +#endif /* AI_AIRPORT_HPP */ diff --git a/src/ai/api/ai_airport.hpp.sq b/src/ai/api/ai_airport.hpp.sq new file mode 100644 index 000000000..355a2ab12 --- /dev/null +++ b/src/ai/api/ai_airport.hpp.sq @@ -0,0 +1,57 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_airport.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIAirport::AirportType GetParam(ForceType<AIAirport::AirportType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIAirport::AirportType)tmp; } + template <> int Return<AIAirport::AirportType>(HSQUIRRELVM vm, AIAirport::AirportType res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIAirport::PlaneType GetParam(ForceType<AIAirport::PlaneType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIAirport::PlaneType)tmp; } + template <> int Return<AIAirport::PlaneType>(HSQUIRRELVM vm, AIAirport::PlaneType res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIAirport to be used as Squirrel parameter */ + template <> AIAirport *GetParam(ForceType<AIAirport *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIAirport *)instance; } + template <> AIAirport &GetParam(ForceType<AIAirport &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAirport *)instance; } + template <> const AIAirport *GetParam(ForceType<const AIAirport *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIAirport *)instance; } + template <> const AIAirport &GetParam(ForceType<const AIAirport &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAirport *)instance; } + template <> int Return<AIAirport *>(HSQUIRRELVM vm, AIAirport *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAirport", res, NULL, DefSQDestructorCallback<AIAirport>); return 1; } +}; // namespace SQConvert + +void SQAIAirport_Register(Squirrel *engine) { + DefSQClass <AIAirport> SQAIAirport("AIAirport"); + SQAIAirport.PreRegister(engine); + SQAIAirport.AddConstructor<void (AIAirport::*)(), 1>(engine, "x"); + + SQAIAirport.DefSQConst(engine, AIAirport::AT_SMALL, "AT_SMALL"); + SQAIAirport.DefSQConst(engine, AIAirport::AT_LARGE, "AT_LARGE"); + SQAIAirport.DefSQConst(engine, AIAirport::AT_METROPOLITAN, "AT_METROPOLITAN"); + SQAIAirport.DefSQConst(engine, AIAirport::AT_INTERNATIONAL, "AT_INTERNATIONAL"); + SQAIAirport.DefSQConst(engine, AIAirport::AT_COMMUTER, "AT_COMMUTER"); + SQAIAirport.DefSQConst(engine, AIAirport::AT_INTERCON, "AT_INTERCON"); + SQAIAirport.DefSQConst(engine, AIAirport::AT_HELIPORT, "AT_HELIPORT"); + SQAIAirport.DefSQConst(engine, AIAirport::AT_HELISTATION, "AT_HELISTATION"); + SQAIAirport.DefSQConst(engine, AIAirport::AT_HELIDEPOT, "AT_HELIDEPOT"); + SQAIAirport.DefSQConst(engine, AIAirport::AT_INVALID, "AT_INVALID"); + SQAIAirport.DefSQConst(engine, AIAirport::PT_HELICOPTER, "PT_HELICOPTER"); + SQAIAirport.DefSQConst(engine, AIAirport::PT_SMALL_PLANE, "PT_SMALL_PLANE"); + SQAIAirport.DefSQConst(engine, AIAirport::PT_BIG_PLANE, "PT_BIG_PLANE"); + SQAIAirport.DefSQConst(engine, AIAirport::PT_INVALID, "PT_INVALID"); + + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::GetClassName, "GetClassName", 1, "x"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::IsValidAirportType, "IsValidAirportType", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::IsHangarTile, "IsHangarTile", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::IsAirportTile, "IsAirportTile", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::AirportAvailable, "AirportAvailable", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::GetAirportWidth, "GetAirportWidth", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::GetAirportHeight, "GetAirportHeight", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::GetAirportCoverageRadius, "GetAirportCoverageRadius", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::GetNumHangars, "GetNumHangars", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::GetHangarOfAirport, "GetHangarOfAirport", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::BuildAirport, "BuildAirport", 4, "xiib"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::RemoveAirport, "RemoveAirport", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::GetAirportType, "GetAirportType", 2, "xi"); + SQAIAirport.DefSQStaticMethod(engine, &AIAirport::GetNoiseLevelIncrease, "GetNoiseLevelIncrease", 3, "xii"); + + SQAIAirport.PostRegister(engine); +} diff --git a/src/ai/api/ai_base.cpp b/src/ai/api/ai_base.cpp new file mode 100644 index 000000000..fa04bac36 --- /dev/null +++ b/src/ai/api/ai_base.cpp @@ -0,0 +1,43 @@ +/* $Id$ */ + +/** @file ai_base.cpp Implementation of AIBase. */ + +#include "ai_base.hpp" +#include "../../network/network.h" +#include "../../core/random_func.hpp" + +/* static */ uint32 AIBase::Rand() +{ + /* We pick RandomRange if we are in SP (so when saved, we do the same over and over) + * but we pick InteractiveRandomRange if we are a network_server or network-client. */ + if (_networking) return ::InteractiveRandom(); + return ::Random(); +} + +/* static */ uint32 AIBase::RandItem(int unused_param) +{ + return AIBase::Rand(); +} + +/* static */ uint AIBase::RandRange(uint max) +{ + /* We pick RandomRange if we are in SP (so when saved, we do the same over and over) + * but we pick InteractiveRandomRange if we are a network_server or network-client. */ + if (_networking) return ::InteractiveRandomRange(max); + return ::RandomRange(max); +} + +/* static */ uint32 AIBase::RandRangeItem(int unused_param, uint max) +{ + return AIBase::RandRange(max); +} + +/* static */ bool AIBase::Chance(uint out, uint max) +{ + return (uint16)Rand() <= (uint16)((65536 * out) / max); +} + +/* static */ bool AIBase::ChanceItem(int unused_param, uint out, uint max) +{ + return AIBase::Chance(out, max); +} diff --git a/src/ai/api/ai_base.hpp b/src/ai/api/ai_base.hpp new file mode 100644 index 000000000..9a3aad742 --- /dev/null +++ b/src/ai/api/ai_base.hpp @@ -0,0 +1,71 @@ +/* $Id$ */ + +/** @file ai_base.hpp Everything to query basic things. */ + +#ifndef AI_BASE_HPP +#define AI_BASE_HPP + +#include "ai_object.hpp" + +/** + * Class that handles some basic functions. + * + * @note The random functions are not called Random and RandomRange, because + * RANDOM_DEBUG does some tricky stuff, which messes with those names. + * @note In MP we cannot use Random because that will cause desyncs (AIs are + * ran on the server only, not on all clients). This means that + * we use InteractiveRandom in MP. Rand() takes care of this for you. + */ +class AIBase : public AIObject { +public: + static const char *GetClassName() { return "AIBase"; } + + /** + * Get a random value. + * @return A random value between 0 and MAX(uint32). + */ + static uint32 Rand(); + + /** + * Get a random value. + * @param unused_param This param is not used, but is needed to work with lists. + * @return A random value between 0 and MAX(uint32). + */ + static uint32 RandItem(int unused_param); + + /** + * Get a random value in a range. + * @param max The first number this function will never return (the maximum it returns is max - 1). + * @return A random value between 0 .. max - 1. + */ + static uint RandRange(uint max); + + /** + * Get a random value in a range. + * @param unused_param This param is not used, but is needed to work with lists. + * @param max The first number this function will never return (the maximum it returns is max - 1). + * @return A random value between 0 .. max - 1. + */ + static uint RandRangeItem(int unused_param, uint max); + + /** + * Returns approximatelly 'out' times true when called 'max' times. + * After all, it is a random function. + * @param out How many times it should return true. + * @param max Out of this many times. + * @return True if the chance worked out. + */ + static bool Chance(uint out, uint max); + + /** + * Returns approximatelly 'out' times true when called 'max' times. + * After all, it is a random function. + * @param unused_param This param is not used, but is needed to work with lists. + * @param out How many times it should return true. + * @param max Out of this many times. + * @return True if the chance worked out. + */ + static bool ChanceItem(int unused_param, uint out, uint max); +}; + +#endif /* AI_BASE_HPP */ diff --git a/src/ai/api/ai_base.hpp.sq b/src/ai/api/ai_base.hpp.sq new file mode 100644 index 000000000..577301936 --- /dev/null +++ b/src/ai/api/ai_base.hpp.sq @@ -0,0 +1,29 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_base.hpp" + +namespace SQConvert { + /* Allow AIBase to be used as Squirrel parameter */ + template <> AIBase *GetParam(ForceType<AIBase *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIBase *)instance; } + template <> AIBase &GetParam(ForceType<AIBase &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIBase *)instance; } + template <> const AIBase *GetParam(ForceType<const AIBase *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIBase *)instance; } + template <> const AIBase &GetParam(ForceType<const AIBase &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIBase *)instance; } + template <> int Return<AIBase *>(HSQUIRRELVM vm, AIBase *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIBase", res, NULL, DefSQDestructorCallback<AIBase>); return 1; } +}; // namespace SQConvert + +void SQAIBase_Register(Squirrel *engine) { + DefSQClass <AIBase> SQAIBase("AIBase"); + SQAIBase.PreRegister(engine); + SQAIBase.AddConstructor<void (AIBase::*)(), 1>(engine, "x"); + + SQAIBase.DefSQStaticMethod(engine, &AIBase::GetClassName, "GetClassName", 1, "x"); + SQAIBase.DefSQStaticMethod(engine, &AIBase::Rand, "Rand", 1, "x"); + SQAIBase.DefSQStaticMethod(engine, &AIBase::RandItem, "RandItem", 2, "xi"); + SQAIBase.DefSQStaticMethod(engine, &AIBase::RandRange, "RandRange", 2, "xi"); + SQAIBase.DefSQStaticMethod(engine, &AIBase::RandRangeItem, "RandRangeItem", 3, "xii"); + SQAIBase.DefSQStaticMethod(engine, &AIBase::Chance, "Chance", 3, "xii"); + SQAIBase.DefSQStaticMethod(engine, &AIBase::ChanceItem, "ChanceItem", 4, "xiii"); + + SQAIBase.PostRegister(engine); +} diff --git a/src/ai/api/ai_bridge.cpp b/src/ai/api/ai_bridge.cpp new file mode 100644 index 000000000..86eb5f6f1 --- /dev/null +++ b/src/ai/api/ai_bridge.cpp @@ -0,0 +1,177 @@ +/* $Id$ */ + +/** @file ai_bridge.cpp Implementation of AIBridge. */ + +#include "ai_bridge.hpp" +#include "ai_rail.hpp" +#include "../ai_instance.hpp" +#include "../../openttd.h" +#include "../../bridge_map.h" +#include "../../strings_func.h" +#include "../../core/alloc_func.hpp" +#include "../../economy_func.h" +#include "../../settings_type.h" +#include "../../road_map.h" +#include "table/strings.h" + +/* static */ bool AIBridge::IsValidBridge(BridgeID bridge_id) +{ + return bridge_id < MAX_BRIDGES; +} + +/* static */ bool AIBridge::IsBridgeTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + return ::IsBridgeTile(tile); +} + +static void _DoCommandReturnBuildBridge2(class AIInstance *instance) +{ + if (!AIBridge::_BuildBridgeRoad2()) { + AIObject::SetLastCommandRes(false); + AIInstance::DoCommandReturn(instance); + return; + } + + /* This can never happen, as in test-mode this callback is never executed, + * and in execute-mode, the other callback is called. */ + NOT_REACHED(); +} + +static void _DoCommandReturnBuildBridge1(class AIInstance *instance) +{ + if (!AIBridge::_BuildBridgeRoad1()) { + AIObject::SetLastCommandRes(false); + AIInstance::DoCommandReturn(instance); + return; + } + + /* This can never happen, as in test-mode this callback is never executed, + * and in execute-mode, the other callback is called. */ + NOT_REACHED(); +} + +/* static */ bool AIBridge::BuildBridge(AIVehicle::VehicleType vehicle_type, BridgeID bridge_id, TileIndex start, TileIndex end) +{ + EnforcePrecondition(false, start != end); + EnforcePrecondition(false, ::IsValidTile(start) && ::IsValidTile(end)); + EnforcePrecondition(false, TileX(start) == TileX(end) || TileY(start) == TileY(end)); + EnforcePrecondition(false, vehicle_type == AIVehicle::VEHICLE_ROAD || vehicle_type == AIVehicle::VEHICLE_RAIL || vehicle_type == AIVehicle::VEHICLE_WATER); + EnforcePrecondition(false, vehicle_type != AIVehicle::VEHICLE_RAIL || AIRail::IsRailTypeAvailable(AIRail::GetCurrentRailType())); + + uint type = 0; + switch (vehicle_type) { + case AIVehicle::VEHICLE_ROAD: + type |= (TRANSPORT_ROAD << 15); + type |= (RoadTypeToRoadTypes((::RoadType)AIObject::GetRoadType()) << 8); + break; + case AIVehicle::VEHICLE_RAIL: + type |= (TRANSPORT_RAIL << 15); + type |= (AIRail::GetCurrentRailType() << 8); + break; + case AIVehicle::VEHICLE_WATER: + type |= (TRANSPORT_WATER << 15); + break; + default: NOT_REACHED(); + } + + /* For rail and water we do nothing special */ + if (vehicle_type == AIVehicle::VEHICLE_RAIL || vehicle_type == AIVehicle::VEHICLE_WATER) { + return AIObject::DoCommand(end, start, type | bridge_id, CMD_BUILD_BRIDGE); + } + + AIObject::SetCallbackVariable(0, start); + if (!AIObject::DoCommand(end, start, type | bridge_id, CMD_BUILD_BRIDGE, NULL, &_DoCommandReturnBuildBridge1)) return false; + + /* In case of test-mode, test if we can build both road pieces */ + return _BuildBridgeRoad1(); +} + +/* static */ bool AIBridge::_BuildBridgeRoad1() +{ + /* Build the piece of road on the 'start' side of the bridge */ + TileIndex end = AIObject::GetCallbackVariable(0); + TileIndex start = AIBridge::GetOtherBridgeEnd(end); + + DiagDirection dir_1 = (DiagDirection)((::TileX(start) == ::TileX(end)) ? (::TileY(start) < ::TileY(end) ? DIAGDIR_NW : DIAGDIR_SE) : (::TileX(start) < ::TileX(end) ? DIAGDIR_NE : DIAGDIR_SW)); + DiagDirection dir_2 = ::ReverseDiagDir(dir_1); + + if (!AIObject::DoCommand(start + ::TileOffsByDiagDir(dir_1), ::DiagDirToRoadBits(dir_2) | (AIObject::GetRoadType() << 4), 0, CMD_BUILD_ROAD, NULL, &_DoCommandReturnBuildBridge2)) return false; + + /* In case of test-mode, test the other road piece too */ + return _BuildBridgeRoad2(); +} + +/* static */ bool AIBridge::_BuildBridgeRoad2() +{ + /* Build the piece of road on the 'end' side of the bridge */ + TileIndex end = AIObject::GetCallbackVariable(0); + TileIndex start = AIBridge::GetOtherBridgeEnd(end); + + DiagDirection dir_1 = (DiagDirection)((::TileX(start) == ::TileX(end)) ? (::TileY(start) < ::TileY(end) ? DIAGDIR_NW : DIAGDIR_SE) : (::TileX(start) < ::TileX(end) ? DIAGDIR_NE : DIAGDIR_SW)); + DiagDirection dir_2 = ::ReverseDiagDir(dir_1); + + return AIObject::DoCommand(end + ::TileOffsByDiagDir(dir_2), ::DiagDirToRoadBits(dir_1) | (AIObject::GetRoadType() << 4), 0, CMD_BUILD_ROAD); +} + +/* static */ bool AIBridge::RemoveBridge(TileIndex tile) +{ + EnforcePrecondition(false, IsBridgeTile(tile)); + return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR); +} + +/* static */ const char *AIBridge::GetName(BridgeID bridge_id) +{ + if (!IsValidBridge(bridge_id)) return NULL; + + static const int len = 64; + char *bridge_name = MallocT<char>(len); + + ::GetString(bridge_name, ::GetBridgeSpec(bridge_id)->transport_name[0], &bridge_name[len - 1]); + return bridge_name; +} + +/* static */ int32 AIBridge::GetMaxSpeed(BridgeID bridge_id) +{ + if (!IsValidBridge(bridge_id)) return -1; + + return ::GetBridgeSpec(bridge_id)->speed; +} + +/* static */ Money AIBridge::GetPrice(BridgeID bridge_id, uint length) +{ + if (!IsValidBridge(bridge_id)) return -1; + + return length * _price.build_bridge * ::GetBridgeSpec(bridge_id)->price >> 8; +} + +/* static */ int32 AIBridge::GetMaxLength(BridgeID bridge_id) +{ + if (!IsValidBridge(bridge_id)) return -1; + + uint max = ::GetBridgeSpec(bridge_id)->max_length; + if (max >= 16 && _settings_game.construction.longbridges) max = 100; + return max + 2; +} + +/* static */ int32 AIBridge::GetMinLength(BridgeID bridge_id) +{ + if (!IsValidBridge(bridge_id)) return -1; + + return ::GetBridgeSpec(bridge_id)->min_length + 2; +} + +/* static */ int32 AIBridge::GetYearAvailable(BridgeID bridge_id) +{ + if (!IsValidBridge(bridge_id)) return -1; + + return ::GetBridgeSpec(bridge_id)->avail_year; +} + +/* static */ TileIndex AIBridge::GetOtherBridgeEnd(TileIndex tile) +{ + if (!::IsValidTile(tile)) return INVALID_TILE; + if (!IsBridgeTile(tile)) return INVALID_TILE; + + return ::GetOtherBridgeEnd(tile); +} diff --git a/src/ai/api/ai_bridge.hpp b/src/ai/api/ai_bridge.hpp new file mode 100644 index 000000000..7bd637277 --- /dev/null +++ b/src/ai/api/ai_bridge.hpp @@ -0,0 +1,164 @@ +/* $Id$ */ + +/** @file ai_bridge.hpp Everything to query and build bridges. */ + +#ifndef AI_BRIDGE_HPP +#define AI_BRIDGE_HPP + +#include "ai_object.hpp" +#include "ai_vehicle.hpp" +#include "ai_error.hpp" + +/** + * Class that handles all bridge related functions. + */ +class AIBridge : public AIObject { +public: + /** + * All bridge related error messages. + */ + enum ErrorMessages { + /** Base for bridge related errors */ + ERR_BRIDGE_BASE = AIError::ERR_CAT_BRIDGE << AIError::ERR_CAT_BIT_SIZE, + + /** + * The bridge you want to build is not available yet, + * or it is not available for the requested length. + */ + ERR_BRIDGE_TYPE_UNAVAILABLE, // [STR_5015_CAN_T_BUILD_BRIDGE_HERE] + + /** One (or more) of the bridge head(s) ends in water. */ + ERR_BRIDGE_CANNOT_END_IN_WATER, // [STR_02A0_ENDS_OF_BRIDGE_MUST_BOTH] + + /** The bride heads need to be on the same height */ + ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT, // [STR_BRIDGEHEADS_NOT_SAME_HEIGHT] + }; + + static const char *GetClassName() { return "AIBridge"; } + + /** + * Checks whether the given bridge type is valid. + * @param bridge_id The bridge to check. + * @return True if and only if the bridge type is valid. + */ + static bool IsValidBridge(BridgeID bridge_id); + + /** + * Checks whether the given tile is actually a bridge start or end tile. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile is the beginning or end of a bridge. + */ + static bool IsBridgeTile(TileIndex tile); + + /** + * Get the name of a bridge. + * @param bridge_id The bridge to get the name of. + * @pre IsValidBridge(bridge_id). + * @return The name the bridge has. + */ + static const char *GetName(BridgeID bridge_id); + + /** + * Get the maximum speed of a bridge (in km/h). + * @param bridge_id The bridge to get the maximum speed of. + * @pre IsValidBridge(bridge_id). + * @return The maximum speed the bridge has. + */ + static int32 GetMaxSpeed(BridgeID bridge_id); + + /** + * Get the new cost of a bridge. + * @param bridge_id The bridge to get the new cost of. + * @param length The length of the bridge. + * @pre IsValidBridge(bridge_id). + * @return The new cost the bridge has. + */ + static Money GetPrice(BridgeID bridge_id, uint length); + + /** + * Get the maximum length of a bridge. + * @param bridge_id The bridge to get the maximum length of. + * @pre IsValidBridge(bridge_id). + * @returns The maximum length the bridge has. + */ + static int32 GetMaxLength(BridgeID bridge_id); + + /** + * Get the minimum length of a bridge. + * @param bridge_id The bridge to get the minimum length of. + * @pre IsValidBridge(bridge_id). + * @returns The minimum length the bridge has. + */ + static int32 GetMinLength(BridgeID bridge_id); + + /** + * Get the year in which a bridge becomes available. + * @param bridge_id The bridge to get the year of availability of. + * @pre IsValidBridge(bridge_id). + * @returns The year of availability the bridge has. + * @note Years are like 2010, -10 (10 B.C.), 1950, .. + */ + static int32 GetYearAvailable(BridgeID bridge_id); + +#ifndef DOXYGEN_SKIP + /** + * Internal function to help BuildBridge in case of road. + */ + static bool _BuildBridgeRoad1(); + + /** + * Internal function to help BuildBridge in case of road. + */ + static bool _BuildBridgeRoad2(); +#endif + + /** + * Build a bridge from one tile to the other. + * As an extra for road, this functions builds two half-pieces of road on + * each end of the bridge, making it easier for you to connect it to your + * network. + * @param vehicle_type The vehicle-type of bridge to build. + * @param bridge_id The bridge-type to build. + * @param start Where to start the bridge. + * @param end Where to end the bridge. + * @pre AIMap::IsValidTile(start). + * @pre AIMap::IsValidTile(end). + * @pre 'start' and 'end' are in a straight line, i.e. + * AIMap::GetTileX(start) == AIMap::GetTileX(end) or + * AIMap::GetTileY(start) == AIMap::GetTileY(end). + * @pre vehicle_type == AIVehicle::VEHICLE_ROAD || (vehicle_type == AIVehicle::VEHICLE_RAIL && + * AIRail::IsRailTypeAvailable(AIRail::GetCurrentRailType())) || vehicle_type == AIVehicle::VEHICLE_WATER. + * @exception AIError::ERR_ALREADY_BUILT + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_LAND_SLOPED_WRONG + * @exception AIError::ERR_VEHICLE_IN_THE_WAY + * @exception AIBridge::ERR_BRIDGE_TYPE_UNAVAILABLE + * @exception AIBridge::ERR_BRIDGE_CANNOT_END_IN_WATER + * @exception AIBridge::ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT + * @return Whether the bridge has been/can be build or not. + * @note No matter if the road pieces were build or not, if building the + * bridge succeeded, this function returns true. + */ + static bool BuildBridge(AIVehicle::VehicleType vehicle_type, BridgeID bridge_id, TileIndex start, TileIndex end); + + /** + * Removes a bridge, by executing it on either the start or end tile. + * @param tile An end or start tile of the bridge. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return Whether the bridge has been/can be removed or not. + */ + static bool RemoveBridge(TileIndex tile); + + /** + * Get the tile that is on the other end of a bridge starting at tile. + * @param tile The tile that is an end of a bridge. + * @pre AIMap::IsValidTile(tile). + * @pre IsBridgeTile(tile). + * @return The TileIndex that is the other end of the bridge. + */ + static TileIndex GetOtherBridgeEnd(TileIndex tile); +}; + +#endif /* AI_BRIDGE_HPP */ diff --git a/src/ai/api/ai_bridge.hpp.sq b/src/ai/api/ai_bridge.hpp.sq new file mode 100644 index 000000000..6388d82cf --- /dev/null +++ b/src/ai/api/ai_bridge.hpp.sq @@ -0,0 +1,51 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_bridge.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIBridge::ErrorMessages GetParam(ForceType<AIBridge::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIBridge::ErrorMessages)tmp; } + template <> int Return<AIBridge::ErrorMessages>(HSQUIRRELVM vm, AIBridge::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIBridge to be used as Squirrel parameter */ + template <> AIBridge *GetParam(ForceType<AIBridge *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIBridge *)instance; } + template <> AIBridge &GetParam(ForceType<AIBridge &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIBridge *)instance; } + template <> const AIBridge *GetParam(ForceType<const AIBridge *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIBridge *)instance; } + template <> const AIBridge &GetParam(ForceType<const AIBridge &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIBridge *)instance; } + template <> int Return<AIBridge *>(HSQUIRRELVM vm, AIBridge *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIBridge", res, NULL, DefSQDestructorCallback<AIBridge>); return 1; } +}; // namespace SQConvert + +void SQAIBridge_Register(Squirrel *engine) { + DefSQClass <AIBridge> SQAIBridge("AIBridge"); + SQAIBridge.PreRegister(engine); + SQAIBridge.AddConstructor<void (AIBridge::*)(), 1>(engine, "x"); + + SQAIBridge.DefSQConst(engine, AIBridge::ERR_BRIDGE_BASE, "ERR_BRIDGE_BASE"); + SQAIBridge.DefSQConst(engine, AIBridge::ERR_BRIDGE_TYPE_UNAVAILABLE, "ERR_BRIDGE_TYPE_UNAVAILABLE"); + SQAIBridge.DefSQConst(engine, AIBridge::ERR_BRIDGE_CANNOT_END_IN_WATER, "ERR_BRIDGE_CANNOT_END_IN_WATER"); + SQAIBridge.DefSQConst(engine, AIBridge::ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT, "ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT"); + + AIError::RegisterErrorMap(STR_5015_CAN_T_BUILD_BRIDGE_HERE, AIBridge::ERR_BRIDGE_TYPE_UNAVAILABLE); + AIError::RegisterErrorMap(STR_02A0_ENDS_OF_BRIDGE_MUST_BOTH, AIBridge::ERR_BRIDGE_CANNOT_END_IN_WATER); + AIError::RegisterErrorMap(STR_BRIDGEHEADS_NOT_SAME_HEIGHT, AIBridge::ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT); + + AIError::RegisterErrorMapString(AIBridge::ERR_BRIDGE_TYPE_UNAVAILABLE, "ERR_BRIDGE_TYPE_UNAVAILABLE"); + AIError::RegisterErrorMapString(AIBridge::ERR_BRIDGE_CANNOT_END_IN_WATER, "ERR_BRIDGE_CANNOT_END_IN_WATER"); + AIError::RegisterErrorMapString(AIBridge::ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT, "ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT"); + + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::GetClassName, "GetClassName", 1, "x"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::IsValidBridge, "IsValidBridge", 2, "xi"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::IsBridgeTile, "IsBridgeTile", 2, "xi"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::GetName, "GetName", 2, "xi"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::GetMaxSpeed, "GetMaxSpeed", 2, "xi"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::GetPrice, "GetPrice", 3, "xii"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::GetMaxLength, "GetMaxLength", 2, "xi"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::GetMinLength, "GetMinLength", 2, "xi"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::GetYearAvailable, "GetYearAvailable", 2, "xi"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::BuildBridge, "BuildBridge", 5, "xiiii"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::RemoveBridge, "RemoveBridge", 2, "xi"); + SQAIBridge.DefSQStaticMethod(engine, &AIBridge::GetOtherBridgeEnd, "GetOtherBridgeEnd", 2, "xi"); + + SQAIBridge.PostRegister(engine); +} diff --git a/src/ai/api/ai_bridgelist.cpp b/src/ai/api/ai_bridgelist.cpp new file mode 100644 index 000000000..4f2fb2719 --- /dev/null +++ b/src/ai/api/ai_bridgelist.cpp @@ -0,0 +1,25 @@ +/* $Id$ */ + +/** @file ai_bridgelist.cpp Implementation of AIBridgeList and friends. */ + +#include "ai_bridgelist.hpp" +#include "ai_bridge.hpp" +#include "../../openttd.h" +#include "../../bridge.h" +#include "../../date_func.h" + +AIBridgeList::AIBridgeList() +{ + /* Add all bridges, no matter if they are available or not */ + for (byte j = 0; j < MAX_BRIDGES; j++) + if (::GetBridgeSpec(j)->avail_year <= _cur_year) + this->AddItem(j); +} + +AIBridgeList_Length::AIBridgeList_Length(uint length) +{ + for (byte j = 0; j < MAX_BRIDGES; j++) + if (::GetBridgeSpec(j)->avail_year <= _cur_year) + if (length >= (uint)AIBridge::GetMinLength(j) && length <= (uint)AIBridge::GetMaxLength(j)) + this->AddItem(j); +} diff --git a/src/ai/api/ai_bridgelist.hpp b/src/ai/api/ai_bridgelist.hpp new file mode 100644 index 000000000..b3ba39058 --- /dev/null +++ b/src/ai/api/ai_bridgelist.hpp @@ -0,0 +1,34 @@ +/* $Id$ */ + +/** @file ai_bridgelist.hpp List all the bridges. */ + +#ifndef AI_BRIDGELIST_HPP +#define AI_BRIDGELIST_HPP + +#include "ai_abstractlist.hpp" + +/** + * Create a list of bridges. + * @ingroup AIList + */ +class AIBridgeList : public AIAbstractList { +public: + static const char *GetClassName() { return "AIBridgeList"; } + AIBridgeList(); +}; + +/** + * Create a list of bridges that can be built on a specific length. + * @ingroup AIList + */ +class AIBridgeList_Length : public AIAbstractList { +public: + static const char *GetClassName() { return "AIBridgeList_Length"; } + + /** + * @param length The length of the bridge you want to build. + */ + AIBridgeList_Length(uint length); +}; + +#endif /* AI_BRIDGELIST_HPP */ diff --git a/src/ai/api/ai_bridgelist.hpp.sq b/src/ai/api/ai_bridgelist.hpp.sq new file mode 100644 index 000000000..f34b95518 --- /dev/null +++ b/src/ai/api/ai_bridgelist.hpp.sq @@ -0,0 +1,42 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_bridgelist.hpp" + +namespace SQConvert { + /* Allow AIBridgeList to be used as Squirrel parameter */ + template <> AIBridgeList *GetParam(ForceType<AIBridgeList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIBridgeList *)instance; } + template <> AIBridgeList &GetParam(ForceType<AIBridgeList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIBridgeList *)instance; } + template <> const AIBridgeList *GetParam(ForceType<const AIBridgeList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIBridgeList *)instance; } + template <> const AIBridgeList &GetParam(ForceType<const AIBridgeList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIBridgeList *)instance; } + template <> int Return<AIBridgeList *>(HSQUIRRELVM vm, AIBridgeList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIBridgeList", res, NULL, DefSQDestructorCallback<AIBridgeList>); return 1; } +}; // namespace SQConvert + +void SQAIBridgeList_Register(Squirrel *engine) { + DefSQClass <AIBridgeList> SQAIBridgeList("AIBridgeList"); + SQAIBridgeList.PreRegister(engine, "AIAbstractList"); + SQAIBridgeList.AddConstructor<void (AIBridgeList::*)(), 1>(engine, "x"); + + SQAIBridgeList.DefSQStaticMethod(engine, &AIBridgeList::GetClassName, "GetClassName", 1, "x"); + + SQAIBridgeList.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIBridgeList_Length to be used as Squirrel parameter */ + template <> AIBridgeList_Length *GetParam(ForceType<AIBridgeList_Length *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIBridgeList_Length *)instance; } + template <> AIBridgeList_Length &GetParam(ForceType<AIBridgeList_Length &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIBridgeList_Length *)instance; } + template <> const AIBridgeList_Length *GetParam(ForceType<const AIBridgeList_Length *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIBridgeList_Length *)instance; } + template <> const AIBridgeList_Length &GetParam(ForceType<const AIBridgeList_Length &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIBridgeList_Length *)instance; } + template <> int Return<AIBridgeList_Length *>(HSQUIRRELVM vm, AIBridgeList_Length *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIBridgeList_Length", res, NULL, DefSQDestructorCallback<AIBridgeList_Length>); return 1; } +}; // namespace SQConvert + +void SQAIBridgeList_Length_Register(Squirrel *engine) { + DefSQClass <AIBridgeList_Length> SQAIBridgeList_Length("AIBridgeList_Length"); + SQAIBridgeList_Length.PreRegister(engine, "AIAbstractList"); + SQAIBridgeList_Length.AddConstructor<void (AIBridgeList_Length::*)(uint length), 2>(engine, "xi"); + + SQAIBridgeList_Length.DefSQStaticMethod(engine, &AIBridgeList_Length::GetClassName, "GetClassName", 1, "x"); + + SQAIBridgeList_Length.PostRegister(engine); +} diff --git a/src/ai/api/ai_cargo.cpp b/src/ai/api/ai_cargo.cpp new file mode 100644 index 000000000..6843f7134 --- /dev/null +++ b/src/ai/api/ai_cargo.cpp @@ -0,0 +1,57 @@ +/* $Id$ */ + +/** @file ai_cargo.cpp Implementation of AICargo. */ + +#include "ai_cargo.hpp" +#include "../../openttd.h" +#include "../../cargotype.h" +#include "../../economy_func.h" +#include "../../core/alloc_func.hpp" +#include "../../core/bitmath_func.hpp" +#include "../../newgrf_cargo.h" + +/* static */ bool AICargo::IsValidCargo(CargoID cargo_type) +{ + return (cargo_type < NUM_CARGO && ::GetCargo(cargo_type)->IsValid()); +} + +/* static */ const char *AICargo::GetCargoLabel(CargoID cargo_type) +{ + if (!IsValidCargo(cargo_type)) return NULL; + const CargoSpec *cargo = ::GetCargo(cargo_type); + + /* cargo->label is a uint32 packing a 4 character non-terminated string, + * like "PASS", "COAL", "OIL_". New ones can be defined by NewGRFs */ + char *cargo_label = MallocT<char>(sizeof(cargo->label) + 1); + for (uint i = 0; i < sizeof(cargo->label); i++) { + cargo_label[i] = GB(cargo->label, (uint8)(sizeof(cargo->label) - i - 1) * 8, 8); + } + cargo_label[sizeof(cargo->label)] = '\0'; + return cargo_label; +} + +/* static */ bool AICargo::IsFreight(CargoID cargo_type) +{ + if (!IsValidCargo(cargo_type)) return false; + const CargoSpec *cargo = ::GetCargo(cargo_type); + return cargo->is_freight; +} + +/* static */ bool AICargo::HasCargoClass(CargoID cargo_type, CargoClass cargo_class) +{ + if (!IsValidCargo(cargo_type)) return false; + return ::IsCargoInClass(cargo_type, (::CargoClass)cargo_class); +} + +/* static */ AICargo::TownEffect AICargo::GetTownEffect(CargoID cargo_type) +{ + if (!IsValidCargo(cargo_type)) return TE_NONE; + + return (AICargo::TownEffect)GetCargo(cargo_type)->town_effect; +} + +/* static */ Money AICargo::GetCargoIncome(CargoID cargo_type, uint32 distance, uint32 days_in_transit) +{ + if (!IsValidCargo(cargo_type)) return -1; + return ::GetTransportedGoodsIncome(1, distance, Clamp(days_in_transit * 2 / 5, 0, 255), cargo_type); +} diff --git a/src/ai/api/ai_cargo.hpp b/src/ai/api/ai_cargo.hpp new file mode 100644 index 000000000..bde235758 --- /dev/null +++ b/src/ai/api/ai_cargo.hpp @@ -0,0 +1,94 @@ +/* $Id$ */ + +/** @file ai_cargo.hpp Everything to query cargos. */ + +#ifndef AI_CARGO_HPP +#define AI_CARGO_HPP + +#include "ai_object.hpp" + +/** + * Class that handles all cargo related functions. + */ +class AICargo : public AIObject { +public: + static const char *GetClassName() { return "AICargo"; } + + /** + * The classes of cargo (from newgrf_cargo.h). + */ + enum CargoClass { + CC_PASSENGERS = 1 << 0, ///< Passengers + CC_MAIL = 1 << 1, ///< Mail + CC_EXPRESS = 1 << 2, ///< Express cargo (Goods, Food, Candy, but also possible for passengers) + CC_ARMOURED = 1 << 3, ///< Armoured cargo (Valuables, Gold, Diamonds) + CC_BULK = 1 << 4, ///< Bulk cargo (Coal, Grain etc., Ores, Fruit) + CC_PIECE_GOODS = 1 << 5, ///< Piece goods (Livestock, Wood, Steel, Paper) + CC_LIQUID = 1 << 6, ///< Liquids (Oil, Water, Rubber) + CC_REFRIGERATED = 1 << 7, ///< Refrigerated cargo (Food, Fruit) + CC_HAZARDOUS = 1 << 8, ///< Hazardous cargo (Nuclear Fuel, Explosives, etc.) + CC_COVERED = 1 << 9, ///< Covered/Sheltered Freight (Transporation in Box Vans, Silo Wagons, etc.) + }; + + /** + * The effects a cargo can have on a town. + */ + enum TownEffect { + TE_NONE = 0, ///< This cargo has no effect on a town + TE_PASSENGERS = 1, ///< This cargo supplies passengers to a town + TE_MAIL = 2, ///< This cargo supplies mail to a town + TE_GOODS = 3, ///< This cargo supplies goods to a town + TE_WATER = 4, ///< This cargo supplies water to a town + TE_FOOD = 5, ///< This cargo supplies food to a town + }; + + /** + * Checks whether the given cargo type is valid. + * @param cargo_type The cargo to check. + * @return True if and only if the cargo type is valid. + */ + static bool IsValidCargo(CargoID cargo_type); + + /** + * Gets the string representation of the cargo label. + * @param cargo_type The cargo to get the string representation of. + * @return The cargo label. + * @note Never use this to check if it is a certain cargo. NewGRF can + * redefine all of the names. + */ + static const char *GetCargoLabel(CargoID cargo_type); + + /** + * Checks whether the give cargo is a freight or not. + * @param cargo_type The cargo to check on. + * @return True if and only if the cargo is freight. + */ + static bool IsFreight(CargoID cargo_type); + + /** + * Check if this cargo is in the requested cargo class. + * @param cargo_type The cargo to check on. + * @param cargo_class The class to check for. + * @return True if and only if the cargo is in the cargo class. + */ + static bool HasCargoClass(CargoID cargo_type, CargoClass cargo_class); + + /** + * Get the effect this cargo has on a town. + * @param cargo_type The cargo to check on. + * @return The effect this cargo has on a town, or TE_NONE if it has no effect. + */ + static TownEffect GetTownEffect(CargoID cargo_type); + + /** + * Get the income for transporting a piece of cargo over the + * given distance within the specified time. + * @param cargo_type The cargo to transport. + * @param distance The distance the cargo travels from begin to end. + * @param days_in_transit Amount of (game) days the cargo is in transit. The max value of this variable is 637. Any value higher returns the same as 637 would. + * @return The amount of money that would be earned by this trip. + */ + static Money GetCargoIncome(CargoID cargo_type, uint32 distance, uint32 days_in_transit); +}; + +#endif /* AI_CARGO_HPP */ diff --git a/src/ai/api/ai_cargo.hpp.sq b/src/ai/api/ai_cargo.hpp.sq new file mode 100644 index 000000000..015d112b7 --- /dev/null +++ b/src/ai/api/ai_cargo.hpp.sq @@ -0,0 +1,52 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_cargo.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AICargo::CargoClass GetParam(ForceType<AICargo::CargoClass>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AICargo::CargoClass)tmp; } + template <> int Return<AICargo::CargoClass>(HSQUIRRELVM vm, AICargo::CargoClass res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AICargo::TownEffect GetParam(ForceType<AICargo::TownEffect>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AICargo::TownEffect)tmp; } + template <> int Return<AICargo::TownEffect>(HSQUIRRELVM vm, AICargo::TownEffect res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AICargo to be used as Squirrel parameter */ + template <> AICargo *GetParam(ForceType<AICargo *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICargo *)instance; } + template <> AICargo &GetParam(ForceType<AICargo &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICargo *)instance; } + template <> const AICargo *GetParam(ForceType<const AICargo *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICargo *)instance; } + template <> const AICargo &GetParam(ForceType<const AICargo &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICargo *)instance; } + template <> int Return<AICargo *>(HSQUIRRELVM vm, AICargo *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AICargo", res, NULL, DefSQDestructorCallback<AICargo>); return 1; } +}; // namespace SQConvert + +void SQAICargo_Register(Squirrel *engine) { + DefSQClass <AICargo> SQAICargo("AICargo"); + SQAICargo.PreRegister(engine); + SQAICargo.AddConstructor<void (AICargo::*)(), 1>(engine, "x"); + + SQAICargo.DefSQConst(engine, AICargo::CC_PASSENGERS, "CC_PASSENGERS"); + SQAICargo.DefSQConst(engine, AICargo::CC_MAIL, "CC_MAIL"); + SQAICargo.DefSQConst(engine, AICargo::CC_EXPRESS, "CC_EXPRESS"); + SQAICargo.DefSQConst(engine, AICargo::CC_ARMOURED, "CC_ARMOURED"); + SQAICargo.DefSQConst(engine, AICargo::CC_BULK, "CC_BULK"); + SQAICargo.DefSQConst(engine, AICargo::CC_PIECE_GOODS, "CC_PIECE_GOODS"); + SQAICargo.DefSQConst(engine, AICargo::CC_LIQUID, "CC_LIQUID"); + SQAICargo.DefSQConst(engine, AICargo::CC_REFRIGERATED, "CC_REFRIGERATED"); + SQAICargo.DefSQConst(engine, AICargo::CC_HAZARDOUS, "CC_HAZARDOUS"); + SQAICargo.DefSQConst(engine, AICargo::CC_COVERED, "CC_COVERED"); + SQAICargo.DefSQConst(engine, AICargo::TE_NONE, "TE_NONE"); + SQAICargo.DefSQConst(engine, AICargo::TE_PASSENGERS, "TE_PASSENGERS"); + SQAICargo.DefSQConst(engine, AICargo::TE_MAIL, "TE_MAIL"); + SQAICargo.DefSQConst(engine, AICargo::TE_GOODS, "TE_GOODS"); + SQAICargo.DefSQConst(engine, AICargo::TE_WATER, "TE_WATER"); + SQAICargo.DefSQConst(engine, AICargo::TE_FOOD, "TE_FOOD"); + + SQAICargo.DefSQStaticMethod(engine, &AICargo::GetClassName, "GetClassName", 1, "x"); + SQAICargo.DefSQStaticMethod(engine, &AICargo::IsValidCargo, "IsValidCargo", 2, "xi"); + SQAICargo.DefSQStaticMethod(engine, &AICargo::GetCargoLabel, "GetCargoLabel", 2, "xi"); + SQAICargo.DefSQStaticMethod(engine, &AICargo::IsFreight, "IsFreight", 2, "xi"); + SQAICargo.DefSQStaticMethod(engine, &AICargo::HasCargoClass, "HasCargoClass", 3, "xii"); + SQAICargo.DefSQStaticMethod(engine, &AICargo::GetTownEffect, "GetTownEffect", 2, "xi"); + SQAICargo.DefSQStaticMethod(engine, &AICargo::GetCargoIncome, "GetCargoIncome", 4, "xiii"); + + SQAICargo.PostRegister(engine); +} diff --git a/src/ai/api/ai_cargolist.cpp b/src/ai/api/ai_cargolist.cpp new file mode 100644 index 000000000..e480895fc --- /dev/null +++ b/src/ai/api/ai_cargolist.cpp @@ -0,0 +1,46 @@ +/* $Id$ */ + +/** @file ai_cargolist.cpp Implementation of AICargoList and friends. */ + +#include "ai_cargolist.hpp" +#include "ai_industry.hpp" +#include "../../openttd.h" +#include "../../cargotype.h" +#include "../../tile_type.h" +#include "../../industry.h" + +AICargoList::AICargoList() +{ + for (byte i = 0; i < NUM_CARGO; i++) { + const CargoSpec *c = ::GetCargo(i); + if (c->IsValid()) { + this->AddItem(i); + } + } +} + +AICargoList_IndustryAccepting::AICargoList_IndustryAccepting(IndustryID industry_id) +{ + if (!AIIndustry::IsValidIndustry(industry_id)) return; + + Industry *ind = ::GetIndustry(industry_id); + for (uint i = 0; i < lengthof(ind->accepts_cargo); i++) { + CargoID cargo_id = ind->accepts_cargo[i]; + if (cargo_id != CT_INVALID) { + this->AddItem(cargo_id); + } + } +} + +AICargoList_IndustryProducing::AICargoList_IndustryProducing(IndustryID industry_id) +{ + if (!AIIndustry::IsValidIndustry(industry_id)) return; + + Industry *ind = ::GetIndustry(industry_id); + for (uint i = 0; i < lengthof(ind->produced_cargo); i++) { + CargoID cargo_id = ind->produced_cargo[i]; + if (cargo_id != CT_INVALID) { + this->AddItem(cargo_id); + } + } +} diff --git a/src/ai/api/ai_cargolist.hpp b/src/ai/api/ai_cargolist.hpp new file mode 100644 index 000000000..86a99a393 --- /dev/null +++ b/src/ai/api/ai_cargolist.hpp @@ -0,0 +1,48 @@ +/* $Id$ */ + +/** @file ai_cargolist.hpp List all the cargos. */ + +#ifndef AI_CARGOLIST_HPP +#define AI_CARGOLIST_HPP + +#include "ai_abstractlist.hpp" + +/** + * Creates a list of cargos that can be produced in the current game. + * @ingroup AIList + */ +class AICargoList : public AIAbstractList { +public: + static const char *GetClassName() { return "AICargoList"; } + AICargoList(); +}; + +/** + * Creates a list of cargos that the given industry accepts. + * @ingroup AIList + */ +class AICargoList_IndustryAccepting : public AIAbstractList { +public: + static const char *GetClassName() { return "AICargoList_IndustryAccepting"; } + + /** + * @param industry_id The industry to get the list of cargos it accepts from. + */ + AICargoList_IndustryAccepting(IndustryID industry_id); +}; + +/** + * Creates a list of cargos that the given industry can produce. + * @ingroup AIList + */ +class AICargoList_IndustryProducing : public AIAbstractList { +public: + static const char *GetClassName() { return "AICargoList_IndustryProducing"; } + + /** + * @param industry_id The industry to get the list of cargos it produces from. + */ + AICargoList_IndustryProducing(IndustryID industry_id); +}; + +#endif /* AI_CARGOLIST_HPP */ diff --git a/src/ai/api/ai_cargolist.hpp.sq b/src/ai/api/ai_cargolist.hpp.sq new file mode 100644 index 000000000..379afed9b --- /dev/null +++ b/src/ai/api/ai_cargolist.hpp.sq @@ -0,0 +1,61 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_cargolist.hpp" + +namespace SQConvert { + /* Allow AICargoList to be used as Squirrel parameter */ + template <> AICargoList *GetParam(ForceType<AICargoList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICargoList *)instance; } + template <> AICargoList &GetParam(ForceType<AICargoList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICargoList *)instance; } + template <> const AICargoList *GetParam(ForceType<const AICargoList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICargoList *)instance; } + template <> const AICargoList &GetParam(ForceType<const AICargoList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICargoList *)instance; } + template <> int Return<AICargoList *>(HSQUIRRELVM vm, AICargoList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AICargoList", res, NULL, DefSQDestructorCallback<AICargoList>); return 1; } +}; // namespace SQConvert + +void SQAICargoList_Register(Squirrel *engine) { + DefSQClass <AICargoList> SQAICargoList("AICargoList"); + SQAICargoList.PreRegister(engine, "AIAbstractList"); + SQAICargoList.AddConstructor<void (AICargoList::*)(), 1>(engine, "x"); + + SQAICargoList.DefSQStaticMethod(engine, &AICargoList::GetClassName, "GetClassName", 1, "x"); + + SQAICargoList.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AICargoList_IndustryAccepting to be used as Squirrel parameter */ + template <> AICargoList_IndustryAccepting *GetParam(ForceType<AICargoList_IndustryAccepting *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICargoList_IndustryAccepting *)instance; } + template <> AICargoList_IndustryAccepting &GetParam(ForceType<AICargoList_IndustryAccepting &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICargoList_IndustryAccepting *)instance; } + template <> const AICargoList_IndustryAccepting *GetParam(ForceType<const AICargoList_IndustryAccepting *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICargoList_IndustryAccepting *)instance; } + template <> const AICargoList_IndustryAccepting &GetParam(ForceType<const AICargoList_IndustryAccepting &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICargoList_IndustryAccepting *)instance; } + template <> int Return<AICargoList_IndustryAccepting *>(HSQUIRRELVM vm, AICargoList_IndustryAccepting *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AICargoList_IndustryAccepting", res, NULL, DefSQDestructorCallback<AICargoList_IndustryAccepting>); return 1; } +}; // namespace SQConvert + +void SQAICargoList_IndustryAccepting_Register(Squirrel *engine) { + DefSQClass <AICargoList_IndustryAccepting> SQAICargoList_IndustryAccepting("AICargoList_IndustryAccepting"); + SQAICargoList_IndustryAccepting.PreRegister(engine, "AIAbstractList"); + SQAICargoList_IndustryAccepting.AddConstructor<void (AICargoList_IndustryAccepting::*)(IndustryID industry_id), 2>(engine, "xi"); + + SQAICargoList_IndustryAccepting.DefSQStaticMethod(engine, &AICargoList_IndustryAccepting::GetClassName, "GetClassName", 1, "x"); + + SQAICargoList_IndustryAccepting.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AICargoList_IndustryProducing to be used as Squirrel parameter */ + template <> AICargoList_IndustryProducing *GetParam(ForceType<AICargoList_IndustryProducing *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICargoList_IndustryProducing *)instance; } + template <> AICargoList_IndustryProducing &GetParam(ForceType<AICargoList_IndustryProducing &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICargoList_IndustryProducing *)instance; } + template <> const AICargoList_IndustryProducing *GetParam(ForceType<const AICargoList_IndustryProducing *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICargoList_IndustryProducing *)instance; } + template <> const AICargoList_IndustryProducing &GetParam(ForceType<const AICargoList_IndustryProducing &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICargoList_IndustryProducing *)instance; } + template <> int Return<AICargoList_IndustryProducing *>(HSQUIRRELVM vm, AICargoList_IndustryProducing *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AICargoList_IndustryProducing", res, NULL, DefSQDestructorCallback<AICargoList_IndustryProducing>); return 1; } +}; // namespace SQConvert + +void SQAICargoList_IndustryProducing_Register(Squirrel *engine) { + DefSQClass <AICargoList_IndustryProducing> SQAICargoList_IndustryProducing("AICargoList_IndustryProducing"); + SQAICargoList_IndustryProducing.PreRegister(engine, "AIAbstractList"); + SQAICargoList_IndustryProducing.AddConstructor<void (AICargoList_IndustryProducing::*)(IndustryID industry_id), 2>(engine, "xi"); + + SQAICargoList_IndustryProducing.DefSQStaticMethod(engine, &AICargoList_IndustryProducing::GetClassName, "GetClassName", 1, "x"); + + SQAICargoList_IndustryProducing.PostRegister(engine); +} diff --git a/src/ai/api/ai_company.cpp b/src/ai/api/ai_company.cpp new file mode 100644 index 000000000..9a426bd2b --- /dev/null +++ b/src/ai/api/ai_company.cpp @@ -0,0 +1,200 @@ +/* $Id$ */ + +/** @file ai_company.cpp Implementation of AICompany. */ + +#include "ai_company.hpp" +#include "ai_error.hpp" +#include "ai_log.hpp" +#include "../../openttd.h" +#include "../../command_func.h" +#include "../../company_func.h" +#include "../../company_base.h" +#include "../../economy_func.h" +#include "../../strings_func.h" +#include "../../tile_map.h" +#include "../../variables.h" +#include "../../core/alloc_func.hpp" +#include "../../string_func.h" +#include "table/strings.h" + +/* static */ AICompany::CompanyID AICompany::ResolveCompanyID(AICompany::CompanyID company) +{ + if (company == MY_COMPANY) return (CompanyID)((byte)_current_company); + + return ::IsValidCompanyID((::CompanyID)company) ? company : INVALID_COMPANY; +} + +/* static */ bool AICompany::IsMine(AICompany::CompanyID company) +{ + return ResolveCompanyID(company) == ResolveCompanyID(MY_COMPANY); +} + +/* static */ bool AICompany::SetCompanyName(const char *name) +{ + AILog::Error("AICompany::SetCompanyName is obsolete. Use AICompany::SetName instead."); + return AICompany::SetName(name); +} + +/* static */ bool AICompany::SetName(const char *name) +{ + EnforcePrecondition(false, !::StrEmpty(name)); + EnforcePreconditionCustomError(false, ::strlen(name) < MAX_LENGTH_COMPANY_NAME_BYTES, AIError::ERR_PRECONDITION_STRING_TOO_LONG); + + return AIObject::DoCommand(0, 0, 0, CMD_RENAME_COMPANY, name); +} + +/* static */ const char *AICompany::GetCompanyName(AICompany::CompanyID company) +{ + AILog::Error("AICompany::GetCompanyName is obsolete. Use AICompany::GetName instead."); + return AICompany::GetName(company); +} + +/* static */ const char *AICompany::GetName(AICompany::CompanyID company) +{ + company = ResolveCompanyID(company); + if (company == INVALID_COMPANY) return NULL; + + static const int len = 64; + char *company_name = MallocT<char>(len); + + ::SetDParam(0, company); + ::GetString(company_name, STR_COMPANY_NAME, &company_name[len - 1]); + return company_name; +} + +/* static */ bool AICompany::SetPresidentName(const char *name) +{ + EnforcePrecondition(false, !::StrEmpty(name)); + + return AIObject::DoCommand(0, 0, 0, CMD_RENAME_PRESIDENT, name); +} + +/* static */ const char *AICompany::GetPresidentName(AICompany::CompanyID company) +{ + company = ResolveCompanyID(company); + + static const int len = 64; + char *president_name = MallocT<char>(len); + if (company != INVALID_COMPANY) { + ::SetDParam(0, company); + ::GetString(president_name, STR_PRESIDENT_NAME, &president_name[len - 1]); + } else { + *president_name = '\0'; + } + + return president_name; +} + +/* static */ Money AICompany::GetCompanyValue(AICompany::CompanyID company) +{ + company = ResolveCompanyID(company); + if (company == INVALID_COMPANY) return -1; + + return ::CalculateCompanyValue(::GetCompany((CompanyID)company)); +} + +/* static */ Money AICompany::GetBankBalance(AICompany::CompanyID company) +{ + company = ResolveCompanyID(company); + if (company == INVALID_COMPANY) return -1; + + return ::GetCompany((CompanyID)company)->money; +} + +/* static */ Money AICompany::GetLoanAmount() +{ + return ::GetCompany(_current_company)->current_loan; +} + +/* static */ Money AICompany::GetMaxLoanAmount() +{ + return _economy.max_loan; +} + +/* static */ Money AICompany::GetLoanInterval() +{ + return LOAN_INTERVAL; +} + +/* static */ bool AICompany::SetLoanAmount(int32 loan) +{ + EnforcePrecondition(false, loan >= 0); + EnforcePrecondition(false, (loan % GetLoanInterval()) == 0); + EnforcePrecondition(false, loan <= GetMaxLoanAmount()); + EnforcePrecondition(false, (loan - GetLoanAmount() + GetBankBalance(MY_COMPANY)) >= 0); + + if (loan == GetLoanAmount()) return true; + + return AIObject::DoCommand(0, + abs(loan - GetLoanAmount()), 2, + (loan > GetLoanAmount()) ? CMD_INCREASE_LOAN : CMD_DECREASE_LOAN); +} + +/* static */ bool AICompany::SetMinimumLoanAmount(int32 loan) +{ + EnforcePrecondition(false, loan >= 0); + + int32 over_interval = loan % GetLoanInterval(); + if (over_interval != 0) loan += GetLoanInterval() - over_interval; + + EnforcePrecondition(false, loan <= GetMaxLoanAmount()); + + SetLoanAmount(loan); + + return GetLoanAmount() == loan; +} + +/* static */ bool AICompany::BuildCompanyHQ(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_BUILD_COMPANY_HQ); +} + +/* static */ TileIndex AICompany::GetCompanyHQ(CompanyID company) +{ + company = ResolveCompanyID(company); + if (company == INVALID_COMPANY) return INVALID_TILE; + + TileIndex loc = ::GetCompany((CompanyID)company)->location_of_HQ; + return (loc == 0) ? INVALID_TILE : loc; +} + +/* static */ bool AICompany::SetAutoRenewStatus(bool autorenew) +{ + return AIObject::DoCommand(0, 0, autorenew ? 1 : 0, CMD_SET_AUTOREPLACE); +} + +/* static */ bool AICompany::GetAutoRenewStatus(CompanyID company) +{ + company = ResolveCompanyID(company); + if (company == INVALID_COMPANY) return false; + + return ::GetCompany((CompanyID)company)->engine_renew; +} + +/* static */ bool AICompany::SetAutoRenewMonths(int16 months) +{ + return AIObject::DoCommand(0, 1, months, CMD_SET_AUTOREPLACE); +} + +/* static */ int16 AICompany::GetAutoRenewMonths(CompanyID company) +{ + company = ResolveCompanyID(company); + if (company == INVALID_COMPANY) return 0; + + return ::GetCompany((CompanyID)company)->engine_renew_months; +} + +/* static */ bool AICompany::SetAutoRenewMoney(uint32 money) +{ + return AIObject::DoCommand(0, 2, money, CMD_SET_AUTOREPLACE); +} + +/* static */ uint32 AICompany::GetAutoRenewMoney(CompanyID company) +{ + company = ResolveCompanyID(company); + if (company == INVALID_COMPANY) return 0; + + return ::GetCompany((CompanyID)company)->engine_renew_money; +} diff --git a/src/ai/api/ai_company.hpp b/src/ai/api/ai_company.hpp new file mode 100644 index 000000000..2497e43b7 --- /dev/null +++ b/src/ai/api/ai_company.hpp @@ -0,0 +1,214 @@ +/* $Id$ */ + +/** @file ai_company.hpp Everything to query a company's financials and statistics or build company related buildings. */ + +#ifndef AI_COMPANY_HPP +#define AI_COMPANY_HPP + +#include "ai_object.hpp" + +/** + * Class that handles all company related functions. + */ +class AICompany : public AIObject { +public: + static const char *GetClassName() { return "AICompany"; } + + /** Different constants related to CompanyID. */ + enum CompanyID { + INVALID_COMPANY = -1, //!< An invalid company. + FIRST_COMPANY = 0, //!< The first available company. + LAST_COMPANY = 7, //!< The last available company. + MY_COMPANY = 8, //!< Constant that gets resolved to the correct company index for your company. + }; + + /** + * Resolved the given company index to the correct index for the company. If + * the company index was MY_COMPANY it will be resolved to the index of + * your company. If the company with the given index does not exist it will + * return INVALID_COMPANY. + * @param company The company index to resolve. + * @return The resolved company index. + */ + static CompanyID ResolveCompanyID(CompanyID company); + + /** + * Check if a CompanyID is your CompanyID, to ease up checks. + * @param company The company index to check. + * @return True if and only if this company is your CompanyID. + */ + static bool IsMine(CompanyID company); + + /** + * Obsolete, use AICompany::SetName instead. + */ + static bool SetCompanyName(const char *name); + + /** + * Set the name of your company. + * @param name The new name of the company. + * @pre 'name' must have at least one character. + * @pre 'name' must have at most 30 characters. + * @exception AIError::ERR_NAME_IS_NOT_UNIQUE + * @return True if the name was changed. + */ + static bool SetName(const char *name); + + /** + * Obsolete, use AICompany::GetName instead. + */ + static const char *GetCompanyName(CompanyID company); + + /** + * Get the name of the given company. + * @param company The company to get the name for. + * @pre ResolveCompanyID(company) != INVALID_COMPANY + * @return The name of the given company. + */ + static const char *GetName(CompanyID company); + + /** + * Set the name of your president. + * @param name The new name of the president. + * @pre 'name' must have at least one character. + * @exception AIError::ERR_NAME_IS_NOT_UNIQUE + * @return True if the name was changed. + */ + static bool SetPresidentName(const char *name); + + /** + * Get the name of the president of the given company. + * @param company The company to get the president's name for. + * @pre ResolveCompanyID(company) != INVALID_COMPANY + * @return The name of the president of the given company. + */ + static const char *GetPresidentName(CompanyID company); + + /** + * Sets the amount to loan. + * @param loan The amount to loan (multiplier of GetLoanInterval()). + * @pre 'loan' must be non-negative. + * @pre GetLoanInterval() must be a multiplier of GetLoanInterval(). + * @pre 'loan' must be below GetMaxLoanAmount(). + * @pre 'loan' - GetLoanAmount() + GetBankBalance() must be non-negative. + * @return True if the loan could be set to your requested amount. + */ + static bool SetLoanAmount(int32 loan); + + /** + * Sets the minimum amount to loan, i.e. the given amount of loan rounded up. + * @param loan The amount to loan (any positive number). + * @pre 'loan' must be non-negative. + * @pre 'loan' must be below GetMaxLoanAmount(). + * @return True if we could allocate a minimum of "loan" loan. + */ + static bool SetMinimumLoanAmount(int32 loan); + + /** + * Gets the amount your company have loaned. + * @return The amount loaned money. + * @post The return value is always non-negative. + * @post GetLoanInterval() is always a multiplier of the return value. + */ + static Money GetLoanAmount(); + + /** + * Gets the maximum amount your company can loan. + * @return The maximum amount your company can loan. + * @post The return value is always non-negative. + * @post GetLoanInterval() is always a multiplier of the return value. + */ + static Money GetMaxLoanAmount(); + + /** + * Gets the interval/loan step. + * @return The loan step. + * @post Return value is always positive. + */ + static Money GetLoanInterval(); + + /** + * Gets the current value of the given company. + * @param company The company to get the company value of. + * @pre ResolveCompanyID(company) != INVALID_COMPANY + * @return The current value of the given company. + */ + static Money GetCompanyValue(CompanyID company); + + /** + * Gets the bank balance. In other words, the amount of money the given company can spent. + * @param company The company to get the bank balance of. + * @pre ResolveCompanyID(company) != INVALID_COMPANY + * @return The actual bank balance. + */ + static Money GetBankBalance(CompanyID company); + + /** + * Build your company's HQ on the given tile. + * @param tile The tile to build your HQ on, this tile is the most nothern tile of your HQ. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_FLAT_LAND_REQUIRED + * @return True if the HQ could be build. + * @note An HQ can not be removed, only by water or rebuilding; If an HQ is + * build again, the old one is removed. + */ + static bool BuildCompanyHQ(TileIndex tile); + + /** + * Return the location of a company's HQ. + * @param company The company the get the HQ of. + * @pre ResolveCompanyID(company) != INVALID_COMPANY. + * @return The tile of the company's HQ, this tile is the most nothern tile of that HQ, or INVALID_TILE if there is no HQ yet. + */ + static TileIndex GetCompanyHQ(CompanyID company); + + /** + * Set whether autorenew is enabled for your company. + * @param autorenew The new autorenew status. + * @return True if autorenew status has been modified. + */ + static bool SetAutoRenewStatus(bool autorenew); + + /** + * Return whether autorenew is enabled for a company. + * @param company The company to get the autorenew status of. + * @pre ResolveCompanyID(company) != INVALID_COMPANY. + * @return True if autorenew is enabled. + */ + static bool GetAutoRenewStatus(CompanyID company); + + /** + * Set the number of months before/after max age to autorenew an engine for your company. + * @param months The new months between autorenew. + * @return True if autorenew months has been modified. + */ + static bool SetAutoRenewMonths(int16 months); + + /** + * Return the number of months before/after max age to autorenew an engine for a company. + * @param company The company to get the autorenew months of. + * @pre ResolveCompanyID(company) != INVALID_COMPANY. + * @return The months before/after max age of engine. + */ + static int16 GetAutoRenewMonths(CompanyID company); + + /** + * Set the minimum money needed to autorenew an engine for your company. + * @param money The new minimum required money for autorenew to work. + * @return True if autorenew money has been modified. + */ + static bool SetAutoRenewMoney(uint32 money); + + /** + * Return the minimum money needed to autorenew an engine for a company. + * @param company The company to get the autorenew money of. + * @pre ResolveCompanyID(company) != INVALID_COMPANY. + * @return The minimum required money for autorenew to work. + */ + static uint32 GetAutoRenewMoney(CompanyID company); +}; + +DECLARE_POSTFIX_INCREMENT(AICompany::CompanyID); + +#endif /* AI_COMPANY_HPP */ diff --git a/src/ai/api/ai_company.hpp.sq b/src/ai/api/ai_company.hpp.sq new file mode 100644 index 000000000..0f0bb5ccf --- /dev/null +++ b/src/ai/api/ai_company.hpp.sq @@ -0,0 +1,55 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_company.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AICompany::CompanyID GetParam(ForceType<AICompany::CompanyID>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AICompany::CompanyID)tmp; } + template <> int Return<AICompany::CompanyID>(HSQUIRRELVM vm, AICompany::CompanyID res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AICompany to be used as Squirrel parameter */ + template <> AICompany *GetParam(ForceType<AICompany *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICompany *)instance; } + template <> AICompany &GetParam(ForceType<AICompany &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICompany *)instance; } + template <> const AICompany *GetParam(ForceType<const AICompany *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICompany *)instance; } + template <> const AICompany &GetParam(ForceType<const AICompany &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICompany *)instance; } + template <> int Return<AICompany *>(HSQUIRRELVM vm, AICompany *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AICompany", res, NULL, DefSQDestructorCallback<AICompany>); return 1; } +}; // namespace SQConvert + +void SQAICompany_Register(Squirrel *engine) { + DefSQClass <AICompany> SQAICompany("AICompany"); + SQAICompany.PreRegister(engine); + SQAICompany.AddConstructor<void (AICompany::*)(), 1>(engine, "x"); + + SQAICompany.DefSQConst(engine, AICompany::INVALID_COMPANY, "INVALID_COMPANY"); + SQAICompany.DefSQConst(engine, AICompany::FIRST_COMPANY, "FIRST_COMPANY"); + SQAICompany.DefSQConst(engine, AICompany::LAST_COMPANY, "LAST_COMPANY"); + SQAICompany.DefSQConst(engine, AICompany::MY_COMPANY, "MY_COMPANY"); + + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetClassName, "GetClassName", 1, "x"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::ResolveCompanyID, "ResolveCompanyID", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::IsMine, "IsMine", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::SetCompanyName, "SetCompanyName", 2, "xs"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::SetName, "SetName", 2, "xs"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetCompanyName, "GetCompanyName", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetName, "GetName", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::SetPresidentName, "SetPresidentName", 2, "xs"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetPresidentName, "GetPresidentName", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::SetLoanAmount, "SetLoanAmount", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::SetMinimumLoanAmount, "SetMinimumLoanAmount", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetLoanAmount, "GetLoanAmount", 1, "x"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetMaxLoanAmount, "GetMaxLoanAmount", 1, "x"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetLoanInterval, "GetLoanInterval", 1, "x"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetCompanyValue, "GetCompanyValue", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetBankBalance, "GetBankBalance", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::BuildCompanyHQ, "BuildCompanyHQ", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetCompanyHQ, "GetCompanyHQ", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::SetAutoRenewStatus, "SetAutoRenewStatus", 2, "xb"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetAutoRenewStatus, "GetAutoRenewStatus", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::SetAutoRenewMonths, "SetAutoRenewMonths", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetAutoRenewMonths, "GetAutoRenewMonths", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::SetAutoRenewMoney, "SetAutoRenewMoney", 2, "xi"); + SQAICompany.DefSQStaticMethod(engine, &AICompany::GetAutoRenewMoney, "GetAutoRenewMoney", 2, "xi"); + + SQAICompany.PostRegister(engine); +} diff --git a/src/ai/api/ai_controller.cpp b/src/ai/api/ai_controller.cpp new file mode 100644 index 000000000..cb1fb6819 --- /dev/null +++ b/src/ai/api/ai_controller.cpp @@ -0,0 +1,85 @@ +/* $Id$ */ + +/** @file ai_controller.cpp Implementation of AIControler. */ + +#include "../../stdafx.h" +#include "../../openttd.h" +#include "../../company_func.h" +#include "../../core/alloc_func.hpp" +#include "../../string_func.h" +#include "../../settings_type.h" +#include "../../company_base.h" +#include "../../saveload/saveload.h" +#include "table/strings.h" + +#include "../ai.hpp" +#include "ai_controller.hpp" +#include "../ai_info.hpp" +#include "../ai_storage.hpp" +#include "../ai_instance.hpp" +#include "../ai_config.hpp" +#include "ai_log.hpp" + +/* static */ void AIController::SetCommandDelay(int ticks) +{ + if (ticks <= 0) return; + AIObject::SetDoCommandDelay(ticks); +} + +/* static */ void AIController::Sleep(int ticks) +{ + if (ticks <= 0) { + AILog::Warning("Sleep() value should be > 0. Assuming value 1."); + ticks = 1; + } + + throw AI_VMSuspend(ticks, NULL); +} + +/* static */ void AIController::Print(bool error_msg, const char *message) +{ + AILog::Log(error_msg ? AILog::LOG_SQ_ERROR : AILog::LOG_SQ_INFO, message); +} + +AIController::AIController() : + ticks(0), + loaded_library_count(0) +{ +} + +AIController::~AIController() +{ + for (LoadedLibraryList::iterator iter = this->loaded_library.begin(); iter != this->loaded_library.end(); iter++) { + free((void *)(*iter).second); + free((void *)(*iter).first); + } + + this->loaded_library.clear(); +} + +uint AIController::GetTick() +{ + return this->ticks; +} + +int AIController::GetSetting(const char *name) +{ + return AIConfig::GetConfig(_current_company)->GetSetting(name); +} + +bool AIController::LoadedLibrary(const char *library_name, int *next_number, char *fake_class_name, int fake_class_name_len) +{ + LoadedLibraryList::iterator iter = this->loaded_library.find(library_name); + if (iter == this->loaded_library.end()) { + *next_number = ++this->loaded_library_count; + return false; + } + + ttd_strlcpy(fake_class_name, (*iter).second, fake_class_name_len); + return true; +} + +void AIController::AddLoadedLibrary(const char *library_name, const char *fake_class_name) +{ + this->loaded_library[strdup(library_name)] = strdup(fake_class_name); +} diff --git a/src/ai/api/ai_controller.hpp b/src/ai/api/ai_controller.hpp new file mode 100644 index 000000000..1f1df743e --- /dev/null +++ b/src/ai/api/ai_controller.hpp @@ -0,0 +1,117 @@ +/* $Id$ */ + +/** @file ai_controller.hpp The controller of the AI. */ + +#ifndef AI_CONTROLLER_HPP +#define AI_CONTROLLER_HPP + +#include <map> +#ifndef AI_HPP +struct ltstr { bool operator()(const char *s1, const char *s2) const { return strcmp(s1, s2) < 0; } }; +#endif /* AI_HPP */ + +/** + * The Controller, the class each AI should extend. It creates the AI, makes + * sure the logic kicks in correctly, and that GetTick() has a valid value. + */ +class AIController { + friend class AIScanner; + friend class AIInstance; + +public: + static const char *GetClassName() { return "AIController"; } + + /** + * Initializer of the AIController. + */ + AIController(); + + /** + * Destructor of the AIController. + */ + ~AIController(); + + /** + * This function is called to start your AI. Your AI starts here. If you + * return from this function, your AI dies, so make sure that doesn't + * happen. + * @note Cannot be called from within your AI. + */ + void Start(); + + /** + * Find at which tick your AI currently is. + * @return returns the current tick. + */ + uint GetTick(); + + /** + * Get the value of one of your settings you set via info.nut. + * @param name The name of the setting. + * @return the value for the setting, or -1 if the setting is not known. + */ + int GetSetting(const char *name); + + /** + * Change the minimum amount of time the AI should be put in suspend mode + * when you execute a command. Normally in SP this is 1, and in MP it is + * what ever delay the server has been programmed to delay commands + * (normally between 1 and 5). To give a more 'real' effect to your AI, + * you can control that number here. + * @param ticks The minimum amount of ticks to wait. + * @pre Ticks should be positive. Too big values will influence performance of the AI. + * @note If the number is lower then the MP setting, the MP setting wins. + */ + static void SetCommandDelay(int ticks); + + /** + * Sleep for X ticks. The code continues after this line when the X AI ticks + * are passed. Mind that an AI tick is different from in-game ticks and + * differ per AI speed. + * @param ticks the ticks to wait + * @pre ticks > 0. + * @post the value of GetTick() will be changed exactly 'ticks' in value after + * calling this. + */ + static void Sleep(int ticks); + + /** + * When Squirrel triggers a print, this function is called. + * Squirrel calls this when 'print' is used, or when the script made an error. + * @param error_msg If true, it is a Squirrel error message. + * @param message The message Squirrel logged. + * @note Use AILog.Info/Warning/Error instead of 'print'. + */ + static void Print(bool error_msg, const char *message); + +private: + typedef std::map<const char *, const char *, ltstr> LoadedLibraryList; + + uint ticks; + LoadedLibraryList loaded_library; + int loaded_library_count; + + /** + * Register all classes that are known inside the NoAI API. + */ + void RegisterClasses(); + + /** + * Check if a library is already loaded. If found, fake_class_name is filled + * with the fake class name as given via AddLoadedLibrary. If not found, + * next_number is set to the next number available for the fake namespace. + * @param library_name The library to check if already loaded. + * @param next_number The next available number for a library if not already loaded. + * @param fake_class_name The name the library has if already loaded. + * @param fake_class_name_len The maximum length of fake_class_name. + * @return True if the library is already loaded. + */ + bool LoadedLibrary(const char *library_name, int *next_number, char *fake_class_name, int fake_class_name_len); + + /** + * Add a library as loaded. + */ + void AddLoadedLibrary(const char *library_name, const char *fake_class_name); +}; + +#endif /* AI_CONTROLLER_HPP */ diff --git a/src/ai/api/ai_controller.hpp.sq b/src/ai/api/ai_controller.hpp.sq new file mode 100644 index 000000000..d72574be7 --- /dev/null +++ b/src/ai/api/ai_controller.hpp.sq @@ -0,0 +1,12 @@ +#include "ai_controller.hpp" + +void SQAIController_Register(Squirrel *engine) { + DefSQClass <AIController> SQAIController("AIController"); + SQAIController.PreRegister(engine); + SQAIController.DefSQMethod(engine, &AIController::GetTick, "GetTick", 1, "x"); + SQAIController.DefSQStaticMethod(engine, &AIController::SetCommandDelay, "SetCommandDelay", 2, "xi"); + SQAIController.DefSQStaticMethod(engine, &AIController::Sleep, "Sleep", 2, "xi"); + SQAIController.DefSQStaticMethod(engine, &AIController::GetSetting, "GetSetting", 2, "xs"); + SQAIController.DefSQStaticMethod(engine, &AIController::Print, "Print", 3, "xbs"); + SQAIController.PostRegister(engine); +} diff --git a/src/ai/api/ai_date.cpp b/src/ai/api/ai_date.cpp new file mode 100644 index 000000000..b3ad552c9 --- /dev/null +++ b/src/ai/api/ai_date.cpp @@ -0,0 +1,47 @@ +/* $Id$ */ + +/** @file ai_date.cpp Implementation of AIDate. */ + +#include "ai_date.hpp" +#include "../../date_func.h" + +/* static */ int32 AIDate::GetCurrentDate() +{ + return ::_date; +} + +/* static */ int32 AIDate::GetYear(int32 date) +{ + if (date < 0) return -1; + + ::YearMonthDay ymd; + ::ConvertDateToYMD(date, &ymd); + return ymd.year; +} + +/* static */ int32 AIDate::GetMonth(int32 date) +{ + if (date < 0) return -1; + + ::YearMonthDay ymd; + ::ConvertDateToYMD(date, &ymd); + return ymd.month + 1; +} + +/* static */ int32 AIDate::GetDayOfMonth(int32 date) +{ + if (date < 0) return -1; + + ::YearMonthDay ymd; + ::ConvertDateToYMD(date, &ymd); + return ymd.day; +} + +/* static */ int32 AIDate::GetDate(int32 year, int32 month, int32 day_of_month) +{ + if (month < 1 || month > 12) return -1; + if (day_of_month < 1 || day_of_month > 31) return -1; + if (year < 0 || year > MAX_YEAR) return -1; + + return ::ConvertYMDToDate(year, month - 1, day_of_month); +} diff --git a/src/ai/api/ai_date.hpp b/src/ai/api/ai_date.hpp new file mode 100644 index 000000000..973b1b116 --- /dev/null +++ b/src/ai/api/ai_date.hpp @@ -0,0 +1,64 @@ +/* $Id$ */ + +/** @file ai_date.hpp Everything to query and manipulate date related information. */ + +#ifndef AI_DATE_HPP +#define AI_DATE_HPP + +#include "ai_object.hpp" + +/** + * Class that handles all date related (calculation) functions. + * + * @note Months and days of month are 1-based; the first month of the + * year is 1 and the first day of the month is also 1. + * @note Years are zero based; they start with the year 0. + * @note Dates can be used to determine the number of days between + * two different moments in time because they count the number + * of days since the year 0. + */ +class AIDate : public AIObject { +public: + static const char *GetClassName() { return "AIDate"; } + + /** + * Get the current date. + * This is the number of days since epoch under the assumption that + * there is a leap year every 4 years, except when dividable by + * 100 but not by 400. + * @return The current date. + */ + static int32 GetCurrentDate(); + + /** + * Get the year of the given date. + * @param date The date to get the year of. + * @return The year. + */ + static int32 GetYear(int32 date); + + /** + * Get the month of the given date. + * @param date The date to get the month of. + * @return The month. + */ + static int32 GetMonth(int32 date); + + /** + * Get the day (of the month) of the given date. + * @param date The date to get the day of. + * @return The day. + */ + static int32 GetDayOfMonth(int32 date); + + /** + * Get the date given a year, month and day of month. + * @param year The year of the to-be determined date. + * @param month The month of the to-be determined date. + * @param day_of_month The day of month of the to-be determined date. + * @return The date. + */ + static int32 GetDate(int32 year, int32 month, int32 day_of_month); +}; + +#endif /* AI_DATE_HPP */ diff --git a/src/ai/api/ai_date.hpp.sq b/src/ai/api/ai_date.hpp.sq new file mode 100644 index 000000000..5e6d7797d --- /dev/null +++ b/src/ai/api/ai_date.hpp.sq @@ -0,0 +1,28 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_date.hpp" + +namespace SQConvert { + /* Allow AIDate to be used as Squirrel parameter */ + template <> AIDate *GetParam(ForceType<AIDate *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIDate *)instance; } + template <> AIDate &GetParam(ForceType<AIDate &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIDate *)instance; } + template <> const AIDate *GetParam(ForceType<const AIDate *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIDate *)instance; } + template <> const AIDate &GetParam(ForceType<const AIDate &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIDate *)instance; } + template <> int Return<AIDate *>(HSQUIRRELVM vm, AIDate *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIDate", res, NULL, DefSQDestructorCallback<AIDate>); return 1; } +}; // namespace SQConvert + +void SQAIDate_Register(Squirrel *engine) { + DefSQClass <AIDate> SQAIDate("AIDate"); + SQAIDate.PreRegister(engine); + SQAIDate.AddConstructor<void (AIDate::*)(), 1>(engine, "x"); + + SQAIDate.DefSQStaticMethod(engine, &AIDate::GetClassName, "GetClassName", 1, "x"); + SQAIDate.DefSQStaticMethod(engine, &AIDate::GetCurrentDate, "GetCurrentDate", 1, "x"); + SQAIDate.DefSQStaticMethod(engine, &AIDate::GetYear, "GetYear", 2, "xi"); + SQAIDate.DefSQStaticMethod(engine, &AIDate::GetMonth, "GetMonth", 2, "xi"); + SQAIDate.DefSQStaticMethod(engine, &AIDate::GetDayOfMonth, "GetDayOfMonth", 2, "xi"); + SQAIDate.DefSQStaticMethod(engine, &AIDate::GetDate, "GetDate", 4, "xiii"); + + SQAIDate.PostRegister(engine); +} diff --git a/src/ai/api/ai_depotlist.cpp b/src/ai/api/ai_depotlist.cpp new file mode 100644 index 000000000..b93ec3aef --- /dev/null +++ b/src/ai/api/ai_depotlist.cpp @@ -0,0 +1,42 @@ +/* $Id$ */ + +/** @file ai_depotlist.cpp Implementation of AIDepotList and friends. */ + +#include "ai_depotlist.hpp" +#include "../../core/math_func.hpp" +#include "../../tile_map.h" +#include "../../company_func.h" +#include "../../depot_base.h" +#include "../../station_base.h" + +AIDepotList::AIDepotList(AITile::TransportType transport_type) +{ + ::TileType tile_type; + switch (transport_type) { + default: return; + + case AITile::TRANSPORT_ROAD: tile_type = ::MP_ROAD; break; + case AITile::TRANSPORT_RAIL: tile_type = ::MP_RAILWAY; break; + case AITile::TRANSPORT_WATER: tile_type = ::MP_WATER; break; + + case AITile::TRANSPORT_AIR: { + /* Hangars are not seen as real depots by the depot code. */ + const Station *st; + FOR_ALL_STATIONS(st) { + if (st->owner == ::_current_company) { + const AirportFTAClass *afc = st->Airport(); + for (uint i = 0; i < afc->nof_depots; i++) { + this->AddItem(st->xy + ToTileIndexDiff(afc->airport_depots[i])); + } + } + } + return; + } + } + + /* Handle 'standard' depots. */ + const Depot *depot; + FOR_ALL_DEPOTS(depot) { + if (::GetTileOwner(depot->xy) == ::_current_company && ::IsTileType(depot->xy, tile_type)) this->AddItem(depot->xy); + } +} diff --git a/src/ai/api/ai_depotlist.hpp b/src/ai/api/ai_depotlist.hpp new file mode 100644 index 000000000..0715b45bb --- /dev/null +++ b/src/ai/api/ai_depotlist.hpp @@ -0,0 +1,25 @@ +/* $Id$ */ + +/** @file ai_depotlist.hpp List all the depots (you own). */ + +#ifndef AI_DEPOTLIST_HPP +#define AI_DEPOTLIST_HPP + +#include "ai_abstractlist.hpp" +#include "ai_tile.hpp" + +/** + * Creates a list of the locations of the depots (and hangars) of which you are the owner. + * @ingroup AIList + */ +class AIDepotList : public AIAbstractList { +public: + static const char *GetClassName() { return "AIDepotList"; } + + /** + * @param transport_type The type of transport to make a list of depots for. + */ + AIDepotList(AITile::TransportType transport_type); +}; + +#endif /* AI_DEPOTLIST_HPP */ diff --git a/src/ai/api/ai_depotlist.hpp.sq b/src/ai/api/ai_depotlist.hpp.sq new file mode 100644 index 000000000..51f799490 --- /dev/null +++ b/src/ai/api/ai_depotlist.hpp.sq @@ -0,0 +1,23 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_depotlist.hpp" + +namespace SQConvert { + /* Allow AIDepotList to be used as Squirrel parameter */ + template <> AIDepotList *GetParam(ForceType<AIDepotList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIDepotList *)instance; } + template <> AIDepotList &GetParam(ForceType<AIDepotList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIDepotList *)instance; } + template <> const AIDepotList *GetParam(ForceType<const AIDepotList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIDepotList *)instance; } + template <> const AIDepotList &GetParam(ForceType<const AIDepotList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIDepotList *)instance; } + template <> int Return<AIDepotList *>(HSQUIRRELVM vm, AIDepotList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIDepotList", res, NULL, DefSQDestructorCallback<AIDepotList>); return 1; } +}; // namespace SQConvert + +void SQAIDepotList_Register(Squirrel *engine) { + DefSQClass <AIDepotList> SQAIDepotList("AIDepotList"); + SQAIDepotList.PreRegister(engine, "AIAbstractList"); + SQAIDepotList.AddConstructor<void (AIDepotList::*)(AITile::TransportType transport_type), 2>(engine, "xi"); + + SQAIDepotList.DefSQStaticMethod(engine, &AIDepotList::GetClassName, "GetClassName", 1, "x"); + + SQAIDepotList.PostRegister(engine); +} diff --git a/src/ai/api/ai_engine.cpp b/src/ai/api/ai_engine.cpp new file mode 100644 index 000000000..5215c95f3 --- /dev/null +++ b/src/ai/api/ai_engine.cpp @@ -0,0 +1,295 @@ +/* $Id$ */ + +/** @file ai_engine.cpp Implementation of AIEngine. */ + +#include "ai_engine.hpp" +#include "ai_cargo.hpp" +#include "ai_rail.hpp" +#include "../../openttd.h" +#include "../../company_func.h" +#include "../../strings_func.h" +#include "../../roadveh.h" +#include "../../train.h" +#include "../../ship.h" +#include "../../aircraft.h" +#include "../../vehicle_func.h" +#include "../../core/alloc_func.hpp" +#include "../../economy_func.h" +#include "../../core/bitmath_func.hpp" +#include "../../settings_type.h" +#include "../../articulated_vehicles.h" +#include "table/strings.h" + +/* static */ bool AIEngine::IsValidEngine(EngineID engine_id) +{ + return ::IsEngineIndex(engine_id) && HasBit(::GetEngine(engine_id)->company_avail, _current_company); +} + +/* static */ const char *AIEngine::GetName(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return NULL; + + static const int len = 64; + char *engine_name = MallocT<char>(len); + + ::SetDParam(0, engine_id); + ::GetString(engine_name, STR_ENGINE_NAME, &engine_name[len - 1]); + return engine_name; +} + +/* static */ CargoID AIEngine::GetCargoType(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return CT_INVALID; + + switch (::GetEngine(engine_id)->type) { + case VEH_ROAD: { + const RoadVehicleInfo *vi = ::RoadVehInfo(engine_id); + return vi->cargo_type; + } break; + + case VEH_TRAIN: { + const RailVehicleInfo *vi = ::RailVehInfo(engine_id); + return vi->cargo_type; + } break; + + case VEH_SHIP: { + const ShipVehicleInfo *vi = ::ShipVehInfo(engine_id); + return vi->cargo_type; + } break; + + case VEH_AIRCRAFT: { + return CT_PASSENGERS; + } break; + + default: NOT_REACHED(); + } +} + +/* static */ bool AIEngine::CanRefitCargo(EngineID engine_id, CargoID cargo_id) +{ + if (!IsValidEngine(engine_id)) return false; + if (!AICargo::IsValidCargo(cargo_id)) return false; + + if (GetCargoType(engine_id) == cargo_id) return true; + if (cargo_id == CT_MAIL && ::GetEngine(engine_id)->type == VEH_AIRCRAFT) return true; + if (::GetEngine(engine_id)->type == VEH_SHIP && !ShipVehInfo(engine_id)->refittable) return false; + return ::CanRefitTo(engine_id, cargo_id); +} + +/* static */ bool AIEngine::CanPullCargo(EngineID engine_id, CargoID cargo_id) +{ + if (!IsValidEngine(engine_id)) return false; + if (GetVehicleType(engine_id) != AIVehicle::VEHICLE_RAIL) return false; + if (!AICargo::IsValidCargo(cargo_id)) return false; + + return (::RailVehInfo(engine_id)->ai_passenger_only != 1) || AICargo::HasCargoClass(cargo_id, AICargo::CC_PASSENGERS); +} + + +/* static */ int32 AIEngine::GetCapacity(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return -1; + + switch (::GetEngine(engine_id)->type) { + case VEH_ROAD: + case VEH_TRAIN: { + uint16 *capacities = GetCapacityOfArticulatedParts(engine_id, ::GetEngine(engine_id)->type); + for (CargoID c = 0; c < NUM_CARGO; c++) { + if (capacities[c] == 0) continue; + return capacities[c]; + } + return -1; + } break; + + case VEH_SHIP: { + const ShipVehicleInfo *vi = ::ShipVehInfo(engine_id); + return vi->capacity; + } break; + + case VEH_AIRCRAFT: { + const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine_id); + return vi->passenger_capacity; + } break; + + default: NOT_REACHED(); + } +} + +/* static */ int32 AIEngine::GetReliability(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return -1; + + return (::GetEngine(engine_id)->reliability * 100 >> 16); +} + +/* static */ int32 AIEngine::GetMaxSpeed(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return -1; + + switch (::GetEngine(engine_id)->type) { + case VEH_ROAD: { + const RoadVehicleInfo *vi = ::RoadVehInfo(engine_id); + /* Internal speeds are km/h * 2 */ + return vi->max_speed / 2; + } break; + + case VEH_TRAIN: { + const RailVehicleInfo *vi = ::RailVehInfo(engine_id); + return vi->max_speed; + } break; + + case VEH_SHIP: { + const ShipVehicleInfo *vi = ::ShipVehInfo(engine_id); + /* Internal speeds are km/h * 2 */ + return vi->max_speed / 2; + } break; + + case VEH_AIRCRAFT: { + const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine_id); + return vi->max_speed / _settings_game.vehicle.plane_speed; + } break; + + default: NOT_REACHED(); + } +} + +/* static */ Money AIEngine::GetPrice(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return -1; + + switch (::GetEngine(engine_id)->type) { + case VEH_ROAD: { + const RoadVehicleInfo *vi = ::RoadVehInfo(engine_id); + return (_price.roadveh_base >> 3) * vi->cost_factor >> 5; + } break; + + case VEH_TRAIN: { + const RailVehicleInfo *vi = ::RailVehInfo(engine_id); + return (_price.build_railvehicle >> 3) * vi->cost_factor >> 5; + } break; + + case VEH_SHIP: { + const ShipVehicleInfo *vi = ::ShipVehInfo(engine_id); + return (_price.ship_base >> 3) * vi->cost_factor >> 5; + } break; + + case VEH_AIRCRAFT: { + const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine_id); + return (_price.aircraft_base >> 3) * vi->cost_factor >> 5; + } break; + + default: NOT_REACHED(); + } +} + +/* static */ int32 AIEngine::GetMaxAge(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return -1; + + return ::GetEngine(engine_id)->lifelength * 366; +} + +/* static */ Money AIEngine::GetRunningCost(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return -1; + + /* We need to create an instance in order to obtain GetRunningCost. + * This means we temporary allocate a vehicle in the pool, but + * there is no other way.. */ + Vehicle *vehicle; + switch (::GetEngine(engine_id)->type) { + case VEH_ROAD: { + vehicle = new RoadVehicle(); + } break; + + case VEH_TRAIN: { + vehicle = new Train(); + } break; + + case VEH_SHIP: { + vehicle = new Ship(); + } break; + + case VEH_AIRCRAFT: { + vehicle = new Aircraft(); + } break; + + default: NOT_REACHED(); + } + + vehicle->engine_type = engine_id; + Money runningCost = vehicle->GetRunningCost(); + delete vehicle; + return runningCost >> 8; +} + +/* static */ AIVehicle::VehicleType AIEngine::GetVehicleType(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return AIVehicle::VEHICLE_INVALID; + + switch (::GetEngine(engine_id)->type) { + case VEH_ROAD: return AIVehicle::VEHICLE_ROAD; + case VEH_TRAIN: return AIVehicle::VEHICLE_RAIL; + case VEH_SHIP: return AIVehicle::VEHICLE_WATER; + case VEH_AIRCRAFT: return AIVehicle::VEHICLE_AIR; + default: NOT_REACHED(); + } +} + +/* static */ bool AIEngine::IsWagon(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return false; + if (GetVehicleType(engine_id) != AIVehicle::VEHICLE_RAIL) return false; + + return ::RailVehInfo(engine_id)->power == 0; +} + +/* static */ bool AIEngine::CanRunOnRail(EngineID engine_id, AIRail::RailType track_rail_type) +{ + if (!IsValidEngine(engine_id)) return false; + if (GetVehicleType(engine_id) != AIVehicle::VEHICLE_RAIL) return false; + if (!AIRail::IsRailTypeAvailable(track_rail_type)) return false; + + return ::IsCompatibleRail((::RailType)::RailVehInfo(engine_id)->railtype, (::RailType)track_rail_type); +} + +/* static */ bool AIEngine::HasPowerOnRail(EngineID engine_id, AIRail::RailType track_rail_type) +{ + if (!IsValidEngine(engine_id)) return false; + if (GetVehicleType(engine_id) != AIVehicle::VEHICLE_RAIL) return false; + if (!AIRail::IsRailTypeAvailable(track_rail_type)) return false; + + return ::HasPowerOnRail((::RailType)::RailVehInfo(engine_id)->railtype, (::RailType)track_rail_type); +} + +/* static */ AIRoad::RoadType AIEngine::GetRoadType(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return AIRoad::ROADTYPE_INVALID; + if (GetVehicleType(engine_id) != AIVehicle::VEHICLE_ROAD) return AIRoad::ROADTYPE_INVALID; + + return HasBit(::EngInfo(engine_id)->misc_flags, EF_ROAD_TRAM) ? AIRoad::ROADTYPE_TRAM : AIRoad::ROADTYPE_ROAD; +} + +/* static */ AIRail::RailType AIEngine::GetRailType(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return AIRail::RAILTYPE_INVALID; + if (GetVehicleType(engine_id) != AIVehicle::VEHICLE_RAIL) return AIRail::RAILTYPE_INVALID; + + return (AIRail::RailType)(uint)::RailVehInfo(engine_id)->railtype; +} + +/* static */ bool AIEngine::IsArticulated(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return false; + if (GetVehicleType(engine_id) != AIVehicle::VEHICLE_ROAD && GetVehicleType(engine_id) != AIVehicle::VEHICLE_RAIL) return false; + + return CountArticulatedParts(engine_id, true) != 0; +} + +/* static */ AIAirport::PlaneType AIEngine::GetPlaneType(EngineID engine_id) +{ + if (!IsValidEngine(engine_id)) return AIAirport::PT_INVALID; + if (GetVehicleType(engine_id) != AIVehicle::VEHICLE_AIR) return AIAirport::PT_INVALID; + + return (AIAirport::PlaneType)::AircraftVehInfo(engine_id)->subtype; +} diff --git a/src/ai/api/ai_engine.hpp b/src/ai/api/ai_engine.hpp new file mode 100644 index 000000000..67801107c --- /dev/null +++ b/src/ai/api/ai_engine.hpp @@ -0,0 +1,202 @@ +/* $Id$ */ + +/** @file ai_engine.hpp Everything to query and build engines. */ + +#ifndef AI_ENGINE_HPP +#define AI_ENGINE_HPP + +#include "ai_object.hpp" +#include "ai_vehicle.hpp" +#include "ai_road.hpp" +#include "ai_rail.hpp" +#include "ai_airport.hpp" + +/** + * Class that handles all engine related functions. + */ +class AIEngine : public AIObject { +public: + static const char *GetClassName() { return "AIEngine"; } + + /** + * Checks whether the given engine type is valid and buildable by you. + * @param engine_id The engine to check. + * @return True if and only if the engine type is valid. + */ + static bool IsValidEngine(EngineID engine_id); + + /** + * Get the name of an engine. + * @param engine_id The engine to get the name of. + * @pre IsValidEngine(engine_id). + * @return The name the engine has. + */ + static const char *GetName(EngineID engine_id); + + /** + * Get the cargo-type of an engine. In case it can transport 2 cargos, it + * returns the first. + * @param engine_id The engine to get the cargo-type of. + * @pre IsValidEngine(engine_id). + * @return The cargo-type of the engine. + */ + static CargoID GetCargoType(EngineID engine_id); + + /** + * Check if the cargo of an engine can be refitted to your requested. If + * the engine already allows this cargo, the function also returns true. + * @param engine_id The engine to check for refitting. + * @param cargo_id The cargo to check for refitting. + * @pre IsValidEngine(engine_id). + * @pre AICargo::IsValidCargo(cargo_id). + * @return True if the engine can carry this cargo, either via refit, or + * by default. + */ + static bool CanRefitCargo(EngineID engine_id, CargoID cargo_id); + + /** + * Check if the engine can pull a wagon with the given cargo. + * @param engine_id The engine to check. + * @param cargo_id The cargo to check. + * @pre IsValidEngine(engine_id). + * @pre GetVehicleType(engine_id) == AIVehicle.VEHICLE_RAIL. + * @pre AICargo::IsValidCargo(cargo_id). + * @return True if the engine can pull wagons carrying this cargo. + * @note This function is not exhaustive; a true here does not mean + * that the vehicle can pull the wagons, a false does mean it can't. + */ + static bool CanPullCargo(EngineID engine_id, CargoID cargo_id); + + /** + * Get the capacity of an engine. In case it can transport 2 cargos, it + * returns the first. + * @param engine_id The engine to get the capacity of. + * @pre IsValidEngine(engine_id). + * @return The capacity of the engine. + */ + static int32 GetCapacity(EngineID engine_id); + + /** + * Get the reliability of an engine. The value is between 0 and 100, where + * 100 means 100% reliability (never breaks down) and 0 means 0% + * reliability (you most likely don't want to buy it). + * @param engine_id The engine to get the reliability of. + * @pre IsValidEngine(engine_id). + * @return The reliability the engine has. + */ + static int32 GetReliability(EngineID engine_id); + + /** + * Get the maximum speed of an engine. + * @param engine_id The engine to get the maximum speed of. + * @pre IsValidEngine(engine_id). + * @return The maximum speed the engine has. + * @note The speed is in km/h. + */ + static int32 GetMaxSpeed(EngineID engine_id); + + /** + * Get the new cost of an engine. + * @param engine_id The engine to get the new cost of. + * @pre IsValidEngine(engine_id). + * @return The new cost the engine has. + */ + static Money GetPrice(EngineID engine_id); + + /** + * Get the maximum age of a brand new engine. + * @param engine_id The engine to get the maximum age of. + * @pre IsValidEngine(engine_id). + * @returns The maximum age of a new engine in days. + * @note Age is in days; divide by 366 to get per year. + */ + static int32 GetMaxAge(EngineID engine_id); + + /** + * Get the running cost of an engine. + * @param engine_id The engine to get the running cost of. + * @pre IsValidEngine(engine_id). + * @return The running cost of a vehicle per year. + * @note Cost is per year; divide by 364 to get per day. + */ + static Money GetRunningCost(EngineID engine_id); + + /** + * Get the type of an engine. + * @param engine_id The engine to get the type of. + * @pre IsValidEngine(engine_id). + * @return The type the engine has. + */ + static AIVehicle::VehicleType GetVehicleType(EngineID engine_id); + + /** + * Check if an engine is a wagon. + * @param engine_id The engine to check. + * @pre IsValidEngine(engine_id). + * @pre GetVehicleType(engine_id) == AIVehicle.VEHICLE_RAIL. + * @return Whether or not the engine is a wagon. + */ + static bool IsWagon(EngineID engine_id); + + /** + * Check if a train vehicle can run on a RailType. + * @param engine_id The engine to check. + * @param track_rail_type The type you want to check. + * @pre IsValidEngine(engine_id). + * @pre GetVehicleType(engine_id) == AIVehicle::VEHICLE_RAIL. + * @pre AIRail::IsRailTypeAvailable(track_rail_type). + * @return Whether an engine of type 'engine_id' can run on 'track_rail_type'. + * @note Even if a train can run on a RailType that doesn't mean that it'll be + * able to power the train. Use HasPowerOnRail for that. + */ + static bool CanRunOnRail(EngineID engine_id, AIRail::RailType track_rail_type); + + /** + * Check if a train engine has power on a RailType. + * @param engine_id The engine to check. + * @param track_rail_type Another RailType. + * @pre IsValidEngine(engine_id). + * @pre GetVehicleType(engine_id) == AIVehicle::VEHICLE_RAIL. + * @pre AIRail::IsRailTypeAvailable(track_rail_type). + * @return Whether an engine of type 'engine_id' has power on 'track_rail_type'. + */ + static bool HasPowerOnRail(EngineID engine_id, AIRail::RailType track_rail_type); + + /** + * Get the RoadType of the engine. + * @param engine_id The engine to get the RoadType of. + * @pre IsValidEngine(engine_id). + * @pre GetVehicleType(engine_id) == AIVehicle.VEHICLE_ROAD. + * @return The RoadType the engine has. + */ + static AIRoad::RoadType GetRoadType(EngineID engine_id); + + /** + * Get the RailType of the engine. + * @param engine_id The engine to get the RailType of. + * @pre IsValidEngine(engine_id). + * @pre GetVehicleType(engine_id) == AIVehicle.VEHICLE_RAIL. + * @return The RailType the engine has. + */ + static AIRail::RailType GetRailType(EngineID engine_id); + + /** + * Check if the engine is articulated. + * @param engine_id The engine to check. + * @pre IsValidEngine(engine_id). + * @pre GetVehicleType(engine_id) == AIVehicle.VEHICLE_ROAD || GetVehicleType(engine_id) == AIVehicle.VEHICLE_RAIL. + * @return True if the engine is articulated. + */ + static bool IsArticulated(EngineID engine_id); + + /** + * Get the PlaneType of the engine. + * @param engine_id The engine to get the PlaneType of. + * @pre IsValidEngine(engine_id). + * @pre GetVehicleType(engine_id) == AIVehicle.VEHICLE_AIR. + * @return The PlaneType the engine has. + */ + static AIAirport::PlaneType GetPlaneType(EngineID engine_id); +}; + +#endif /* AI_ENGINE_HPP */ diff --git a/src/ai/api/ai_engine.hpp.sq b/src/ai/api/ai_engine.hpp.sq new file mode 100644 index 000000000..067d3c65e --- /dev/null +++ b/src/ai/api/ai_engine.hpp.sq @@ -0,0 +1,42 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_engine.hpp" + +namespace SQConvert { + /* Allow AIEngine to be used as Squirrel parameter */ + template <> AIEngine *GetParam(ForceType<AIEngine *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEngine *)instance; } + template <> AIEngine &GetParam(ForceType<AIEngine &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngine *)instance; } + template <> const AIEngine *GetParam(ForceType<const AIEngine *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEngine *)instance; } + template <> const AIEngine &GetParam(ForceType<const AIEngine &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngine *)instance; } + template <> int Return<AIEngine *>(HSQUIRRELVM vm, AIEngine *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngine", res, NULL, DefSQDestructorCallback<AIEngine>); return 1; } +}; // namespace SQConvert + +void SQAIEngine_Register(Squirrel *engine) { + DefSQClass <AIEngine> SQAIEngine("AIEngine"); + SQAIEngine.PreRegister(engine); + SQAIEngine.AddConstructor<void (AIEngine::*)(), 1>(engine, "x"); + + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetClassName, "GetClassName", 1, "x"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::IsValidEngine, "IsValidEngine", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetName, "GetName", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetCargoType, "GetCargoType", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::CanRefitCargo, "CanRefitCargo", 3, "xii"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::CanPullCargo, "CanPullCargo", 3, "xii"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetCapacity, "GetCapacity", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetReliability, "GetReliability", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetMaxSpeed, "GetMaxSpeed", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetPrice, "GetPrice", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetMaxAge, "GetMaxAge", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetRunningCost, "GetRunningCost", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetVehicleType, "GetVehicleType", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::IsWagon, "IsWagon", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::CanRunOnRail, "CanRunOnRail", 3, "xii"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::HasPowerOnRail, "HasPowerOnRail", 3, "xii"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetRoadType, "GetRoadType", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetRailType, "GetRailType", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::IsArticulated, "IsArticulated", 2, "xi"); + SQAIEngine.DefSQStaticMethod(engine, &AIEngine::GetPlaneType, "GetPlaneType", 2, "xi"); + + SQAIEngine.PostRegister(engine); +} diff --git a/src/ai/api/ai_enginelist.cpp b/src/ai/api/ai_enginelist.cpp new file mode 100644 index 000000000..bd57025f6 --- /dev/null +++ b/src/ai/api/ai_enginelist.cpp @@ -0,0 +1,16 @@ +/* $Id$ */ + +/** @file ai_enginelist.cpp Implementation of AIEngineList and friends. */ + +#include "ai_enginelist.hpp" +#include "../../company_func.h" +#include "../../engine_base.h" +#include "../../core/bitmath_func.hpp" + +AIEngineList::AIEngineList(AIVehicle::VehicleType vehicle_type) +{ + Engine *e; + FOR_ALL_ENGINES_OF_TYPE(e, (::VehicleType)vehicle_type) { + if (HasBit(e->company_avail, _current_company)) this->AddItem(e->index); + } +} diff --git a/src/ai/api/ai_enginelist.hpp b/src/ai/api/ai_enginelist.hpp new file mode 100644 index 000000000..8c299caf3 --- /dev/null +++ b/src/ai/api/ai_enginelist.hpp @@ -0,0 +1,25 @@ +/* $Id$ */ + +/** @file ai_enginelist.hpp List all the engines. */ + +#ifndef AI_ENGINELIST_HPP +#define AI_ENGINELIST_HPP + +#include "ai_abstractlist.hpp" +#include "ai_vehicle.hpp" + +/** + * Create a list of engines based on a vehicle type. + * @ingroup AIList + */ +class AIEngineList : public AIAbstractList { +public: + static const char *GetClassName() { return "AIEngineList"; } + + /** + * @param vehicle_type The type of vehicle to make a list of engines for. + */ + AIEngineList(AIVehicle::VehicleType vehicle_type); +}; + +#endif /* AI_ENGINELIST_HPP */ diff --git a/src/ai/api/ai_enginelist.hpp.sq b/src/ai/api/ai_enginelist.hpp.sq new file mode 100644 index 000000000..98054d22d --- /dev/null +++ b/src/ai/api/ai_enginelist.hpp.sq @@ -0,0 +1,23 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_enginelist.hpp" + +namespace SQConvert { + /* Allow AIEngineList to be used as Squirrel parameter */ + template <> AIEngineList *GetParam(ForceType<AIEngineList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEngineList *)instance; } + template <> AIEngineList &GetParam(ForceType<AIEngineList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList *)instance; } + template <> const AIEngineList *GetParam(ForceType<const AIEngineList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEngineList *)instance; } + template <> const AIEngineList &GetParam(ForceType<const AIEngineList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList *)instance; } + template <> int Return<AIEngineList *>(HSQUIRRELVM vm, AIEngineList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineList", res, NULL, DefSQDestructorCallback<AIEngineList>); return 1; } +}; // namespace SQConvert + +void SQAIEngineList_Register(Squirrel *engine) { + DefSQClass <AIEngineList> SQAIEngineList("AIEngineList"); + SQAIEngineList.PreRegister(engine, "AIAbstractList"); + SQAIEngineList.AddConstructor<void (AIEngineList::*)(AIVehicle::VehicleType vehicle_type), 2>(engine, "xi"); + + SQAIEngineList.DefSQStaticMethod(engine, &AIEngineList::GetClassName, "GetClassName", 1, "x"); + + SQAIEngineList.PostRegister(engine); +} diff --git a/src/ai/api/ai_error.cpp b/src/ai/api/ai_error.cpp new file mode 100644 index 000000000..4c21db726 --- /dev/null +++ b/src/ai/api/ai_error.cpp @@ -0,0 +1,60 @@ +/* $Id$ */ + +/** @file ai_error.cpp Implementation of AIError. */ + +#include "ai_error.hpp" +#include "table/strings.h" +#include "../../core/bitmath_func.hpp" + +AIError::AIErrorMap AIError::error_map = AIError::AIErrorMap(); +AIError::AIErrorMapString AIError::error_map_string = AIError::AIErrorMapString(); + +/* static */ AIErrorType AIError::GetLastError() +{ + return AIObject::GetLastError(); +} + +/* static */ const char *AIError::GetLastErrorString() +{ + return (*error_map_string.find(AIError::GetLastError())).second; +} + +/* static */ AIErrorType AIError::StringToError(StringID internal_string_id) +{ + uint index = GB(internal_string_id, 11, 5); + switch (GB(internal_string_id, 11, 5)) { + case 26: case 28: case 29: case 30: // NewGRF strings. + return ERR_NEWGRF_SUPPLIED_ERROR; + + /* DO NOT SWAP case 14 and 4 because that will break StringToError due + * to the index dependency that relies on FALL THROUGHs. */ + case 14: if (index < 0xE4) break; // Player name + case 4: if (index < 0xC0) break; // Town name + case 15: // Custom name + case 31: // Dynamic strings + /* These strings are 'random' and have no meaning. + * They actually shouldn't even be returned as error messages. */ + return ERR_UNKNOWN; + + default: + break; + } + + AIErrorMap::iterator it = error_map.find(internal_string_id); + if (it == error_map.end()) return ERR_UNKNOWN; + return (*it).second; +} + +/* static */ void AIError::RegisterErrorMap(StringID internal_string_id, AIErrorType ai_error_msg) +{ + error_map[internal_string_id] = ai_error_msg; +} + +/* static */ void AIError::RegisterErrorMapString(AIErrorType ai_error_msg, const char *message) +{ + error_map_string[ai_error_msg] = message; +} + +/* static */ AIError::ErrorCategories AIError::GetErrorCategory() { + return (AIError::ErrorCategories)(GetLastError() >> (uint)ERR_CAT_BIT_SIZE); +} diff --git a/src/ai/api/ai_error.hpp b/src/ai/api/ai_error.hpp new file mode 100644 index 000000000..6a448ff3a --- /dev/null +++ b/src/ai/api/ai_error.hpp @@ -0,0 +1,171 @@ +/* $Id$ */ + +/** @file ai_error.hpp Everything to query errors. */ + +#ifndef AI_ERROR_HPP +#define AI_ERROR_HPP + +#include "ai_object.hpp" +#include <map> + +/** + * Helper to write precondition enforcers for the AI API in an abbreviated manner. + * @param returnval The value to return on failure. + * @param condition The condition that must be obeyed. + */ +#define EnforcePrecondition(returnval, condition) \ + if (!(condition)) { \ + AIObject::SetLastError(AIError::ERR_PRECONDITION_FAILED); \ + return returnval; \ + } + +/** + * Helper to write precondition enforcers for the AI API in an abbreviated manner. + * @param returnval The value to return on failure. + * @param condition The condition that must be obeyed. + * @param error_code The error code passed to AIObject::SetLastError. + */ +#define EnforcePreconditionCustomError(returnval, condition, error_code) \ + if (!(condition)) { \ + AIObject::SetLastError(error_code); \ + return returnval; \ + } + +/** + * Class that handles all error related functions. + */ +class AIError : public AIObject { +public: + static const char *GetClassName() { return "AIError"; } + + /** + * All categories errors can be divided in. + */ + enum ErrorCategories { + ERR_CAT_NONE = 0, //!< Error messages not related to any category. + ERR_CAT_GENERAL, //!< Error messages related to general things. + ERR_CAT_VEHICLE, //!< Error messages related to building / maintaining vehicles. + ERR_CAT_STATION, //!< Error messages related to building / maintaining stations. + ERR_CAT_BRIDGE, //!< Error messages related to building / removing bridges. + ERR_CAT_TUNNEL, //!< Error messages related to building / removing tunnels. + ERR_CAT_TILE, //!< Error messages related to raising / lowering and demolishing tiles. + ERR_CAT_SIGN, //!< Error messages related to building / removing signs. + ERR_CAT_RAIL, //!< Error messages related to building / maintaining rails. + ERR_CAT_ROAD, //!< Error messages related to building / maintaining roads. + ERR_CAT_ORDER, //!< Error messages related to managing orders. + ERR_CAT_MARINE, //!< Error messages related to building / removing ships, docks and channels. + + /** + * DO NOT USE! The error bitsize determines how many errors can be stored in + * a category and what the offsets are of all categories. + */ + ERR_CAT_BIT_SIZE = 8, + }; + + /** + * All general related error messages. + */ + enum ErrorMessages { + /** Initial error value */ + ERR_NONE = ERR_CAT_NONE << ERR_CAT_BIT_SIZE, // [] + /** If an error occured and the error wasn't mapped */ + ERR_UNKNOWN, // [] + /** If a precondition is not met */ + ERR_PRECONDITION_FAILED, // [] + /** A string supplied was too long */ + ERR_PRECONDITION_STRING_TOO_LONG, // [] + /** An error returned by a NewGRF. No possibility to get the exact error in an AI readable format */ + ERR_NEWGRF_SUPPLIED_ERROR, // [] + + /** Base for general errors */ + ERR_GENERAL_BASE = ERR_CAT_GENERAL << ERR_CAT_BIT_SIZE, + + /** Not enough cash to perform the previous action */ + ERR_NOT_ENOUGH_CASH, // [STR_0003_NOT_ENOUGH_CASH_REQUIRES] + + /** Local authority won't allow the previous action */ + ERR_LOCAL_AUTHORITY_REFUSES, // [STR_2009_LOCAL_AUTHORITY_REFUSES] + + /** The piece of infrastructure you tried to build is already in place */ + ERR_ALREADY_BUILT, // [STR_1007_ALREADY_BUILT, STR_5007_MUST_DEMOLISH_BRIDGE_FIRST] + + /** Area isn't clear, try to demolish the building on it */ + ERR_AREA_NOT_CLEAR, // [STR_2004_BUILDING_MUST_BE_DEMOLISHED, STR_5007_MUST_DEMOLISH_BRIDGE_FIRST, STR_300B_MUST_DEMOLISH_RAILROAD, STR_300E_MUST_DEMOLISH_AIRPORT_FIRST, STR_MUST_DEMOLISH_CARGO_TRAM_STATION, STR_3047_MUST_DEMOLISH_TRUCK_STATION, STR_MUST_DEMOLISH_PASSENGER_TRAM_STATION, STR_3046_MUST_DEMOLISH_BUS_STATION, STR_306A_BUOY_IN_THE_WAY, STR_304D_MUST_DEMOLISH_DOCK_FIRST, STR_4800_IN_THE_WAY, STR_5804_COMPANY_HEADQUARTERS_IN, STR_5800_OBJECT_IN_THE_WAY, STR_1801_MUST_REMOVE_ROAD_FIRST, STR_1008_MUST_REMOVE_RAILROAD_TRACK, STR_5007_MUST_DEMOLISH_BRIDGE_FIRST, STR_5006_MUST_DEMOLISH_TUNNEL_FIRST, STR_1002_EXCAVATION_WOULD_DAMAGE] + + /** Area / property is owned by another company */ + ERR_OWNED_BY_ANOTHER_COMPANY, // [STR_1024_AREA_IS_OWNED_BY_ANOTHER, STR_013B_OWNED_BY] + + /** The name given is not unique for the object type */ + ERR_NAME_IS_NOT_UNIQUE, // [STR_NAME_MUST_BE_UNIQUE] + + /** The building you want to build requires flat land */ + ERR_FLAT_LAND_REQUIRED, // [STR_0007_FLAT_LAND_REQUIRED] + + /** Land is sloped in the wrong direction for this build action */ + ERR_LAND_SLOPED_WRONG, // [STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION] + + /** A vehicle is in the way */ + ERR_VEHICLE_IN_THE_WAY, // [STR_8803_TRAIN_IN_THE_WAY, STR_9000_ROAD_VEHICLE_IN_THE_WAY, STR_980E_SHIP_IN_THE_WAY, STR_A015_AIRCRAFT_IN_THE_WAY] + + /** Site is unsuitable */ + ERR_SITE_UNSUITABLE, // [STR_0239_SITE_UNSUITABLE, STR_304B_SITE_UNSUITABLE] + + /** Too close to the edge of the map */ + ERR_TOO_CLOSE_TO_EDGE, // [STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP] + + /** Station is too spread out */ + ERR_STATION_TOO_SPREAD_OUT, // [STR_306C_STATION_TOO_SPREAD_OUT] + }; + + /** + * Check the membership of the last thrown error. + * @return The category the error belongs to. + * @note The last throw error can be aquired by calling GetLastError(). + */ + static ErrorCategories GetErrorCategory(); + + /** + * Get the last error. + * @return An ErrorMessages enum value. + */ + static AIErrorType GetLastError(); + + /** + * Get the last error in string format (for human readability). + * @return An ErrorMessage enum item, as string. + */ + static const char *GetLastErrorString(); + + /** + * Get the error based on the OpenTTD StringID. + * @note DO NOT INVOKE THIS METHOD YOURSELF! + * @param internal_string_id The string to convert. + * @return The NoAI equivalent error message. + */ + static AIErrorType StringToError(StringID internal_string_id); + + /** + * Map an internal OpenTTD error message to it's NoAI equivalent. + * @note DO NOT INVOKE THIS METHOD YOURSELF! The calls are autogenerated. + * @param internal_string_id The OpenTTD StringID used for an error. + * @param ai_error_msg The NoAI equivalent error message. + */ + static void RegisterErrorMap(StringID internal_string_id, AIErrorType ai_error_msg); + + /** + * Map an internal OpenTTD error message to it's NoAI equivalent. + * @note DO NOT INVOKE THIS METHOD YOURSELF! The calls are autogenerated. + * @param ai_error_msg The NoAI error message representation. + * @param message The string representation of this error message, used for debug purposes. + */ + static void RegisterErrorMapString(AIErrorType ai_error_msg, const char *message); + +private: + typedef std::map<StringID, AIErrorType> AIErrorMap; + typedef std::map<AIErrorType, const char *> AIErrorMapString; + + static AIErrorMap error_map; + static AIErrorMapString error_map_string; +}; + +#endif /* AI_ERROR_HPP */ diff --git a/src/ai/api/ai_error.hpp.sq b/src/ai/api/ai_error.hpp.sq new file mode 100644 index 000000000..1955de76b --- /dev/null +++ b/src/ai/api/ai_error.hpp.sq @@ -0,0 +1,121 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_error.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIError::ErrorCategories GetParam(ForceType<AIError::ErrorCategories>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIError::ErrorCategories)tmp; } + template <> int Return<AIError::ErrorCategories>(HSQUIRRELVM vm, AIError::ErrorCategories res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIError::ErrorMessages GetParam(ForceType<AIError::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIError::ErrorMessages)tmp; } + template <> int Return<AIError::ErrorMessages>(HSQUIRRELVM vm, AIError::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIError to be used as Squirrel parameter */ + template <> AIError *GetParam(ForceType<AIError *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIError *)instance; } + template <> AIError &GetParam(ForceType<AIError &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIError *)instance; } + template <> const AIError *GetParam(ForceType<const AIError *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIError *)instance; } + template <> const AIError &GetParam(ForceType<const AIError &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIError *)instance; } + template <> int Return<AIError *>(HSQUIRRELVM vm, AIError *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIError", res, NULL, DefSQDestructorCallback<AIError>); return 1; } +}; // namespace SQConvert + +void SQAIError_Register(Squirrel *engine) { + DefSQClass <AIError> SQAIError("AIError"); + SQAIError.PreRegister(engine); + SQAIError.AddConstructor<void (AIError::*)(), 1>(engine, "x"); + + SQAIError.DefSQConst(engine, AIError::ERR_CAT_NONE, "ERR_CAT_NONE"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_GENERAL, "ERR_CAT_GENERAL"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_VEHICLE, "ERR_CAT_VEHICLE"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_STATION, "ERR_CAT_STATION"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_BRIDGE, "ERR_CAT_BRIDGE"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_TUNNEL, "ERR_CAT_TUNNEL"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_TILE, "ERR_CAT_TILE"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_SIGN, "ERR_CAT_SIGN"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_RAIL, "ERR_CAT_RAIL"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_ROAD, "ERR_CAT_ROAD"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_ORDER, "ERR_CAT_ORDER"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_MARINE, "ERR_CAT_MARINE"); + SQAIError.DefSQConst(engine, AIError::ERR_CAT_BIT_SIZE, "ERR_CAT_BIT_SIZE"); + SQAIError.DefSQConst(engine, AIError::ERR_NONE, "ERR_NONE"); + SQAIError.DefSQConst(engine, AIError::ERR_UNKNOWN, "ERR_UNKNOWN"); + SQAIError.DefSQConst(engine, AIError::ERR_PRECONDITION_FAILED, "ERR_PRECONDITION_FAILED"); + SQAIError.DefSQConst(engine, AIError::ERR_PRECONDITION_STRING_TOO_LONG, "ERR_PRECONDITION_STRING_TOO_LONG"); + SQAIError.DefSQConst(engine, AIError::ERR_NEWGRF_SUPPLIED_ERROR, "ERR_NEWGRF_SUPPLIED_ERROR"); + SQAIError.DefSQConst(engine, AIError::ERR_GENERAL_BASE, "ERR_GENERAL_BASE"); + SQAIError.DefSQConst(engine, AIError::ERR_NOT_ENOUGH_CASH, "ERR_NOT_ENOUGH_CASH"); + SQAIError.DefSQConst(engine, AIError::ERR_LOCAL_AUTHORITY_REFUSES, "ERR_LOCAL_AUTHORITY_REFUSES"); + SQAIError.DefSQConst(engine, AIError::ERR_ALREADY_BUILT, "ERR_ALREADY_BUILT"); + SQAIError.DefSQConst(engine, AIError::ERR_AREA_NOT_CLEAR, "ERR_AREA_NOT_CLEAR"); + SQAIError.DefSQConst(engine, AIError::ERR_OWNED_BY_ANOTHER_COMPANY, "ERR_OWNED_BY_ANOTHER_COMPANY"); + SQAIError.DefSQConst(engine, AIError::ERR_NAME_IS_NOT_UNIQUE, "ERR_NAME_IS_NOT_UNIQUE"); + SQAIError.DefSQConst(engine, AIError::ERR_FLAT_LAND_REQUIRED, "ERR_FLAT_LAND_REQUIRED"); + SQAIError.DefSQConst(engine, AIError::ERR_LAND_SLOPED_WRONG, "ERR_LAND_SLOPED_WRONG"); + SQAIError.DefSQConst(engine, AIError::ERR_VEHICLE_IN_THE_WAY, "ERR_VEHICLE_IN_THE_WAY"); + SQAIError.DefSQConst(engine, AIError::ERR_SITE_UNSUITABLE, "ERR_SITE_UNSUITABLE"); + SQAIError.DefSQConst(engine, AIError::ERR_TOO_CLOSE_TO_EDGE, "ERR_TOO_CLOSE_TO_EDGE"); + SQAIError.DefSQConst(engine, AIError::ERR_STATION_TOO_SPREAD_OUT, "ERR_STATION_TOO_SPREAD_OUT"); + + AIError::RegisterErrorMap(STR_0003_NOT_ENOUGH_CASH_REQUIRES, AIError::ERR_NOT_ENOUGH_CASH); + AIError::RegisterErrorMap(STR_2009_LOCAL_AUTHORITY_REFUSES, AIError::ERR_LOCAL_AUTHORITY_REFUSES); + AIError::RegisterErrorMap(STR_1007_ALREADY_BUILT, AIError::ERR_ALREADY_BUILT); + AIError::RegisterErrorMap(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST, AIError::ERR_ALREADY_BUILT); + AIError::RegisterErrorMap(STR_2004_BUILDING_MUST_BE_DEMOLISHED, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_300B_MUST_DEMOLISH_RAILROAD, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_300E_MUST_DEMOLISH_AIRPORT_FIRST, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_MUST_DEMOLISH_CARGO_TRAM_STATION, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_3047_MUST_DEMOLISH_TRUCK_STATION, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_MUST_DEMOLISH_PASSENGER_TRAM_STATION, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_3046_MUST_DEMOLISH_BUS_STATION, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_306A_BUOY_IN_THE_WAY, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_304D_MUST_DEMOLISH_DOCK_FIRST, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_4800_IN_THE_WAY, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_5804_COMPANY_HEADQUARTERS_IN, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_5800_OBJECT_IN_THE_WAY, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_1801_MUST_REMOVE_ROAD_FIRST, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_1008_MUST_REMOVE_RAILROAD_TRACK, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_5006_MUST_DEMOLISH_TUNNEL_FIRST, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_1002_EXCAVATION_WOULD_DAMAGE, AIError::ERR_AREA_NOT_CLEAR); + AIError::RegisterErrorMap(STR_1024_AREA_IS_OWNED_BY_ANOTHER, AIError::ERR_OWNED_BY_ANOTHER_COMPANY); + AIError::RegisterErrorMap(STR_013B_OWNED_BY, AIError::ERR_OWNED_BY_ANOTHER_COMPANY); + AIError::RegisterErrorMap(STR_NAME_MUST_BE_UNIQUE, AIError::ERR_NAME_IS_NOT_UNIQUE); + AIError::RegisterErrorMap(STR_0007_FLAT_LAND_REQUIRED, AIError::ERR_FLAT_LAND_REQUIRED); + AIError::RegisterErrorMap(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION, AIError::ERR_LAND_SLOPED_WRONG); + AIError::RegisterErrorMap(STR_8803_TRAIN_IN_THE_WAY, AIError::ERR_VEHICLE_IN_THE_WAY); + AIError::RegisterErrorMap(STR_9000_ROAD_VEHICLE_IN_THE_WAY, AIError::ERR_VEHICLE_IN_THE_WAY); + AIError::RegisterErrorMap(STR_980E_SHIP_IN_THE_WAY, AIError::ERR_VEHICLE_IN_THE_WAY); + AIError::RegisterErrorMap(STR_A015_AIRCRAFT_IN_THE_WAY, AIError::ERR_VEHICLE_IN_THE_WAY); + AIError::RegisterErrorMap(STR_0239_SITE_UNSUITABLE, AIError::ERR_SITE_UNSUITABLE); + AIError::RegisterErrorMap(STR_304B_SITE_UNSUITABLE, AIError::ERR_SITE_UNSUITABLE); + AIError::RegisterErrorMap(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP, AIError::ERR_TOO_CLOSE_TO_EDGE); + AIError::RegisterErrorMap(STR_306C_STATION_TOO_SPREAD_OUT, AIError::ERR_STATION_TOO_SPREAD_OUT); + + AIError::RegisterErrorMapString(AIError::ERR_NONE, "ERR_NONE"); + AIError::RegisterErrorMapString(AIError::ERR_UNKNOWN, "ERR_UNKNOWN"); + AIError::RegisterErrorMapString(AIError::ERR_PRECONDITION_FAILED, "ERR_PRECONDITION_FAILED"); + AIError::RegisterErrorMapString(AIError::ERR_PRECONDITION_STRING_TOO_LONG, "ERR_PRECONDITION_STRING_TOO_LONG"); + AIError::RegisterErrorMapString(AIError::ERR_NEWGRF_SUPPLIED_ERROR, "ERR_NEWGRF_SUPPLIED_ERROR"); + AIError::RegisterErrorMapString(AIError::ERR_NOT_ENOUGH_CASH, "ERR_NOT_ENOUGH_CASH"); + AIError::RegisterErrorMapString(AIError::ERR_LOCAL_AUTHORITY_REFUSES, "ERR_LOCAL_AUTHORITY_REFUSES"); + AIError::RegisterErrorMapString(AIError::ERR_ALREADY_BUILT, "ERR_ALREADY_BUILT"); + AIError::RegisterErrorMapString(AIError::ERR_AREA_NOT_CLEAR, "ERR_AREA_NOT_CLEAR"); + AIError::RegisterErrorMapString(AIError::ERR_OWNED_BY_ANOTHER_COMPANY, "ERR_OWNED_BY_ANOTHER_COMPANY"); + AIError::RegisterErrorMapString(AIError::ERR_NAME_IS_NOT_UNIQUE, "ERR_NAME_IS_NOT_UNIQUE"); + AIError::RegisterErrorMapString(AIError::ERR_FLAT_LAND_REQUIRED, "ERR_FLAT_LAND_REQUIRED"); + AIError::RegisterErrorMapString(AIError::ERR_LAND_SLOPED_WRONG, "ERR_LAND_SLOPED_WRONG"); + AIError::RegisterErrorMapString(AIError::ERR_VEHICLE_IN_THE_WAY, "ERR_VEHICLE_IN_THE_WAY"); + AIError::RegisterErrorMapString(AIError::ERR_SITE_UNSUITABLE, "ERR_SITE_UNSUITABLE"); + AIError::RegisterErrorMapString(AIError::ERR_TOO_CLOSE_TO_EDGE, "ERR_TOO_CLOSE_TO_EDGE"); + AIError::RegisterErrorMapString(AIError::ERR_STATION_TOO_SPREAD_OUT, "ERR_STATION_TOO_SPREAD_OUT"); + + SQAIError.DefSQStaticMethod(engine, &AIError::GetClassName, "GetClassName", 1, "x"); + SQAIError.DefSQStaticMethod(engine, &AIError::GetErrorCategory, "GetErrorCategory", 1, "x"); + SQAIError.DefSQStaticMethod(engine, &AIError::GetLastError, "GetLastError", 1, "x"); + SQAIError.DefSQStaticMethod(engine, &AIError::GetLastErrorString, "GetLastErrorString", 1, "x"); + SQAIError.DefSQStaticMethod(engine, &AIError::StringToError, "StringToError", 2, "xi"); + SQAIError.DefSQStaticMethod(engine, &AIError::RegisterErrorMap, "RegisterErrorMap", 3, "xii"); + SQAIError.DefSQStaticMethod(engine, &AIError::RegisterErrorMapString, "RegisterErrorMapString", 3, "xis"); + + SQAIError.PostRegister(engine); +} diff --git a/src/ai/api/ai_event.cpp b/src/ai/api/ai_event.cpp new file mode 100644 index 000000000..b18fa4777 --- /dev/null +++ b/src/ai/api/ai_event.cpp @@ -0,0 +1,65 @@ +/* $Id$ */ + +/** @file ai_event.cpp Implementation of AIEvent. */ + +#include "ai_event.hpp" +#include "ai_event_types.hpp" + +#include <queue> +#include <set> + +struct AIEventData { + std::queue<AIEvent *> stack; +}; + +/* static */ void AIEventController::CreateEventPointer() +{ + assert(AIObject::GetEventPointer() == NULL); + + AIObject::GetEventPointer() = new AIEventData(); +} + +/* static */ void AIEventController::FreeEventPointer() +{ + AIEventData *data = (AIEventData *)AIObject::GetEventPointer(); + + /* Free all waiting events (if any) */ + while (!data->stack.empty()) { + AIEvent *e = data->stack.front(); + data->stack.pop(); + e->Release(); + } + + /* Now kill our data pointer */ + delete data; +} + +/* static */ bool AIEventController::IsEventWaiting() +{ + if (AIObject::GetEventPointer() == NULL) AIEventController::CreateEventPointer(); + AIEventData *data = (AIEventData *)AIObject::GetEventPointer(); + + return !data->stack.empty(); +} + +/* static */ AIEvent *AIEventController::GetNextEvent() +{ + if (AIObject::GetEventPointer() == NULL) AIEventController::CreateEventPointer(); + AIEventData *data = (AIEventData *)AIObject::GetEventPointer(); + + if (data->stack.empty()) return NULL; + + AIEvent *e = data->stack.front(); + data->stack.pop(); + return e; +} + +/* static */ void AIEventController::InsertEvent(AIEvent *event) +{ + if (AIObject::GetEventPointer() == NULL) AIEventController::CreateEventPointer(); + AIEventData *data = (AIEventData *)AIObject::GetEventPointer(); + + event->AddRef(); + data->stack.push(event); +} + diff --git a/src/ai/api/ai_event.hpp b/src/ai/api/ai_event.hpp new file mode 100644 index 000000000..a1304ec33 --- /dev/null +++ b/src/ai/api/ai_event.hpp @@ -0,0 +1,107 @@ +/* $Id$ */ + +/** @file ai_event.hpp Everything to handle events from the game. */ + +#ifndef AI_EVENT_HPP +#define AI_EVENT_HPP + +#include "ai_object.hpp" + +/** + * Class that handles all event related functions. + * You can lookup the type, and than convert it to the real event-class. + * That way you can request more detailed information about the event. + */ +class AIEvent : public AIObject { +public: + static const char *GetClassName() { return "AIEvent"; } + + /** + * The type of event. Needed to lookup the detailed class. + */ + enum AIEventType { + AI_ET_INVALID = 0, + AI_ET_TEST, + AI_ET_SUBSIDY_OFFER, + AI_ET_SUBSIDY_OFFER_EXPIRED, + AI_ET_SUBSIDY_AWARDED, + AI_ET_SUBSIDY_EXPIRED, + AI_ET_ENGINE_PREVIEW, + AI_ET_COMPANY_NEW, + AI_ET_COMPANY_IN_TROUBLE, + AI_ET_COMPANY_MERGER, + AI_ET_COMPANY_BANKRUPT, + AI_ET_VEHICLE_CRASHED, + AI_ET_VEHICLE_LOST, + AI_ET_VEHICLE_WAITING_IN_DEPOT, + AI_ET_VEHICLE_UNPROFITABLE, + AI_ET_INDUSTRY_OPEN, + AI_ET_INDUSTRY_CLOSE, + AI_ET_ENGINE_AVAILABLE, + AI_ET_STATION_FIRST_VEHICLE, + }; + + /** + * Constructor of AIEvent, to get the type of event. + */ + AIEvent(AIEvent::AIEventType type) : + type(type) + {} + + /** + * Get the event-type. + * @return The @c AIEventType. + */ + AIEventType GetEventType() { return this->type; } + +protected: + /** + * The type of this event. + */ + AIEventType type; +}; + +/** + * Class that handles all event related functions. + * @note it is not needed to create an instance of AIEvent to access it, as + * all members are static, and all data is stored AI-wide. + */ +class AIEventController : public AIObject { +public: + /** + * The name of the class, needed by several sub-processes. + */ + static const char *GetClassName() { return "AIEventController"; } + + /** + * Check if there is an event waiting. + * @return true if there is an event on the stack. + */ + static bool IsEventWaiting(); + + /** + * Get the next event. + * @return a class of the event-child issues. + */ + static AIEvent *GetNextEvent(); + + /** + * Insert an event to the queue for the company. + * @param event The event to insert. + */ + static void InsertEvent(AIEvent *event); + + /** + * Free the event pointer. + * @note DO NOT CALL YOURSELF; leave it to the internal AI programming. + */ + static void FreeEventPointer(); + +private: + /** + * Create the event pointer. + */ + static void CreateEventPointer(); +}; + +#endif /* AI_EVENT_HPP */ diff --git a/src/ai/api/ai_event.hpp.sq b/src/ai/api/ai_event.hpp.sq new file mode 100644 index 000000000..f5ac02203 --- /dev/null +++ b/src/ai/api/ai_event.hpp.sq @@ -0,0 +1,72 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_event.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIEvent::AIEventType GetParam(ForceType<AIEvent::AIEventType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIEvent::AIEventType)tmp; } + template <> int Return<AIEvent::AIEventType>(HSQUIRRELVM vm, AIEvent::AIEventType res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIEvent to be used as Squirrel parameter */ + template <> AIEvent *GetParam(ForceType<AIEvent *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEvent *)instance; } + template <> AIEvent &GetParam(ForceType<AIEvent &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEvent *)instance; } + template <> const AIEvent *GetParam(ForceType<const AIEvent *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEvent *)instance; } + template <> const AIEvent &GetParam(ForceType<const AIEvent &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEvent *)instance; } + template <> int Return<AIEvent *>(HSQUIRRELVM vm, AIEvent *res) { if (res == NULL) { sq_pushnull(vm); return 1; } Squirrel::CreateClassInstanceVM(vm, "AIEvent", res, NULL, DefSQDestructorCallback<AIEvent>); return 1; } +}; // namespace SQConvert + +void SQAIEvent_Register(Squirrel *engine) { + DefSQClass <AIEvent> SQAIEvent("AIEvent"); + SQAIEvent.PreRegister(engine); + SQAIEvent.AddConstructor<void (AIEvent::*)(AIEvent::AIEventType type), 2>(engine, "xi"); + + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_INVALID, "AI_ET_INVALID"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_TEST, "AI_ET_TEST"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_SUBSIDY_OFFER, "AI_ET_SUBSIDY_OFFER"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_SUBSIDY_OFFER_EXPIRED, "AI_ET_SUBSIDY_OFFER_EXPIRED"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_SUBSIDY_AWARDED, "AI_ET_SUBSIDY_AWARDED"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_SUBSIDY_EXPIRED, "AI_ET_SUBSIDY_EXPIRED"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_ENGINE_PREVIEW, "AI_ET_ENGINE_PREVIEW"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_COMPANY_NEW, "AI_ET_COMPANY_NEW"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_COMPANY_IN_TROUBLE, "AI_ET_COMPANY_IN_TROUBLE"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_COMPANY_MERGER, "AI_ET_COMPANY_MERGER"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_COMPANY_BANKRUPT, "AI_ET_COMPANY_BANKRUPT"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_VEHICLE_CRASHED, "AI_ET_VEHICLE_CRASHED"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_VEHICLE_LOST, "AI_ET_VEHICLE_LOST"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_VEHICLE_WAITING_IN_DEPOT, "AI_ET_VEHICLE_WAITING_IN_DEPOT"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_VEHICLE_UNPROFITABLE, "AI_ET_VEHICLE_UNPROFITABLE"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_INDUSTRY_OPEN, "AI_ET_INDUSTRY_OPEN"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_INDUSTRY_CLOSE, "AI_ET_INDUSTRY_CLOSE"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_ENGINE_AVAILABLE, "AI_ET_ENGINE_AVAILABLE"); + SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_STATION_FIRST_VEHICLE, "AI_ET_STATION_FIRST_VEHICLE"); + + SQAIEvent.DefSQStaticMethod(engine, &AIEvent::GetClassName, "GetClassName", 1, "x"); + + SQAIEvent.DefSQMethod(engine, &AIEvent::GetEventType, "GetEventType", 1, "x"); + + SQAIEvent.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventController to be used as Squirrel parameter */ + template <> AIEventController *GetParam(ForceType<AIEventController *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventController *)instance; } + template <> AIEventController &GetParam(ForceType<AIEventController &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventController *)instance; } + template <> const AIEventController *GetParam(ForceType<const AIEventController *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventController *)instance; } + template <> const AIEventController &GetParam(ForceType<const AIEventController &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventController *)instance; } + template <> int Return<AIEventController *>(HSQUIRRELVM vm, AIEventController *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventController", res, NULL, DefSQDestructorCallback<AIEventController>); return 1; } +}; // namespace SQConvert + +void SQAIEventController_Register(Squirrel *engine) { + DefSQClass <AIEventController> SQAIEventController("AIEventController"); + SQAIEventController.PreRegister(engine); + SQAIEventController.AddConstructor<void (AIEventController::*)(), 1>(engine, "x"); + + SQAIEventController.DefSQStaticMethod(engine, &AIEventController::GetClassName, "GetClassName", 1, "x"); + SQAIEventController.DefSQStaticMethod(engine, &AIEventController::IsEventWaiting, "IsEventWaiting", 1, "x"); + SQAIEventController.DefSQStaticMethod(engine, &AIEventController::GetNextEvent, "GetNextEvent", 1, "x"); + SQAIEventController.DefSQStaticMethod(engine, &AIEventController::InsertEvent, "InsertEvent", 2, "xx"); + SQAIEventController.DefSQStaticMethod(engine, &AIEventController::FreeEventPointer, "FreeEventPointer", 1, "x"); + + SQAIEventController.PostRegister(engine); +} diff --git a/src/ai/api/ai_event_types.cpp b/src/ai/api/ai_event_types.cpp new file mode 100644 index 000000000..07b324cfa --- /dev/null +++ b/src/ai/api/ai_event_types.cpp @@ -0,0 +1,187 @@ +/* $Id$ */ + +/** @file ai_event_types.cpp Implementation of all EventTypes. */ + +#include "ai_event_types.hpp" +#include "../../openttd.h" +#include "../../core/alloc_func.hpp" +#include "../../strings_func.h" +#include "../../roadveh.h" +#include "../../train.h" +#include "../../ship.h" +#include "../../aircraft.h" +#include "../../settings_type.h" +#include "../../articulated_vehicles.h" +#include "table/strings.h" + +bool AIEventVehicleCrashed::CloneCrashedVehicle(TileIndex depot) +{ + return false; +} + +const char *AIEventEnginePreview::GetName() +{ + static const int len = 64; + char *engine_name = MallocT<char>(len); + + ::SetDParam(0, engine); + ::GetString(engine_name, STR_ENGINE_NAME, &engine_name[len - 1]); + return engine_name; +} + +CargoID AIEventEnginePreview::GetCargoType() +{ + switch (::GetEngine(engine)->type) { + case VEH_ROAD: { + const RoadVehicleInfo *vi = ::RoadVehInfo(engine); + return vi->cargo_type; + } break; + + case VEH_TRAIN: { + const RailVehicleInfo *vi = ::RailVehInfo(engine); + return vi->cargo_type; + } break; + + case VEH_SHIP: { + const ShipVehicleInfo *vi = ::ShipVehInfo(engine); + return vi->cargo_type; + } break; + + case VEH_AIRCRAFT: { + return CT_PASSENGERS; + } break; + + default: NOT_REACHED(); + } +} + +int32 AIEventEnginePreview::GetCapacity() +{ + switch (::GetEngine(engine)->type) { + case VEH_ROAD: + case VEH_TRAIN: { + uint16 *capacities = GetCapacityOfArticulatedParts(engine, ::GetEngine(engine)->type); + for (CargoID c = 0; c < NUM_CARGO; c++) { + if (capacities[c] == 0) continue; + return capacities[c]; + } + return -1; + } break; + + case VEH_SHIP: { + const ShipVehicleInfo *vi = ::ShipVehInfo(engine); + return vi->capacity; + } break; + + case VEH_AIRCRAFT: { + const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine); + return vi->passenger_capacity; + } break; + + default: NOT_REACHED(); + } +} + +int32 AIEventEnginePreview::GetMaxSpeed() +{ + switch (::GetEngine(engine)->type) { + case VEH_ROAD: { + const RoadVehicleInfo *vi = ::RoadVehInfo(engine); + /* Internal speeds are km/h * 2 */ + return vi->max_speed / 2; + } break; + + case VEH_TRAIN: { + const RailVehicleInfo *vi = ::RailVehInfo(engine); + return vi->max_speed; + } break; + + case VEH_SHIP: { + const ShipVehicleInfo *vi = ::ShipVehInfo(engine); + /* Internal speeds are km/h * 2 */ + return vi->max_speed / 2; + } break; + + case VEH_AIRCRAFT: { + const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine); + return vi->max_speed / _settings_game.vehicle.plane_speed; + } break; + + default: NOT_REACHED(); + } +} + +Money AIEventEnginePreview::GetPrice() +{ + switch (::GetEngine(engine)->type) { + case VEH_ROAD: { + const RoadVehicleInfo *vi = ::RoadVehInfo(engine); + return (_price.roadveh_base >> 3) * vi->cost_factor >> 5; + } break; + + case VEH_TRAIN: { + const RailVehicleInfo *vi = ::RailVehInfo(engine); + return (_price.build_railvehicle >> 3) * vi->cost_factor >> 5; + } break; + + case VEH_SHIP: { + const ShipVehicleInfo *vi = ::ShipVehInfo(engine); + return (_price.ship_base >> 3) * vi->cost_factor >> 5; + } break; + + case VEH_AIRCRAFT: { + const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine); + return (_price.aircraft_base >> 3) * vi->cost_factor >> 5; + } break; + + default: NOT_REACHED(); + } +} + +Money AIEventEnginePreview::GetRunningCost() +{ + /* We need to create an instance in order to obtain GetRunningCost. + * This means we temporary allocate a vehicle in the pool, but + * there is no other way.. */ + Vehicle *vehicle; + switch (::GetEngine(engine)->type) { + case VEH_ROAD: { + vehicle = new RoadVehicle(); + } break; + + case VEH_TRAIN: { + vehicle = new Train(); + } break; + + case VEH_SHIP: { + vehicle = new Ship(); + } break; + + case VEH_AIRCRAFT: { + vehicle = new Aircraft(); + } break; + + default: NOT_REACHED(); + } + + vehicle->engine_type = engine; + Money runningCost = vehicle->GetRunningCost(); + delete vehicle; + return runningCost >> 8; +} + +AIVehicle::VehicleType AIEventEnginePreview::GetVehicleType() +{ + switch (::GetEngine(engine)->type) { + case VEH_ROAD: return AIVehicle::VEHICLE_ROAD; + case VEH_TRAIN: return AIVehicle::VEHICLE_RAIL; + case VEH_SHIP: return AIVehicle::VEHICLE_WATER; + case VEH_AIRCRAFT: return AIVehicle::VEHICLE_AIR; + default: NOT_REACHED(); + } +} + +bool AIEventEnginePreview::AcceptPreview() +{ + return AIObject::DoCommand(0, engine, 0, CMD_WANT_ENGINE_PREVIEW); +} diff --git a/src/ai/api/ai_event_types.hpp b/src/ai/api/ai_event_types.hpp new file mode 100644 index 000000000..c64b2a367 --- /dev/null +++ b/src/ai/api/ai_event_types.hpp @@ -0,0 +1,684 @@ +/* $Id$ */ + +/** @file ai_event_types.hpp The detailed types of all events. */ + +#ifndef AI_EVENT_TYPES_HPP +#define AI_EVENT_TYPES_HPP + +#include "ai_object.hpp" +#include "ai_event.hpp" +#include "ai_town.hpp" +#include "ai_industry.hpp" +#include "ai_engine.hpp" +#include "ai_subsidy.hpp" + +/** + * Event Test: a simple test event, to see if the event system is working. + * Triggered via AIEventController::Test(); + */ +class AIEventTest : public AIEvent { +public: + static const char *GetClassName() { return "AIEventTest"; } + + /** + * @param test A test value. + */ + AIEventTest(uint test) : + AIEvent(AI_ET_TEST), + test(test) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventTest *Convert(AIEvent *instance) { return (AIEventTest *)instance; } + + /** + * Return the test value. + * @return The test value. + */ + uint GetTest() { return this->test; } + +private: + uint test; +}; + +/** + * Event Vehicle Crash, indicating a vehicle of yours is crashed. + * It contains both the crash site as the vehicle crashed. It has a nice + * helper that creates a new vehicle in a depot with the same type + * and orders as the crashed one. In case the vehicle type isn't available + * anymore, it will find the next best. + */ +class AIEventVehicleCrashed : public AIEvent { +public: + static const char *GetClassName() { return "AIEventVehicleCrashed"; } + + /** + * @param vehicle The vehicle that crashed. + * @param crash_site Where the vehicle crashed. + */ + AIEventVehicleCrashed(VehicleID vehicle, TileIndex crash_site) : + AIEvent(AI_ET_VEHICLE_CRASHED), + crash_site(crash_site), + vehicle(vehicle) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventVehicleCrashed *Convert(AIEvent *instance) { return (AIEventVehicleCrashed *)instance; } + + /** + * Get the VehicleID of the crashed vehicle. + * @return The crashed vehicle. + */ + VehicleID GetVehicleID() { return vehicle; } + + /** + * Find the tile the vehicle crashed. + * @return The crash site. + */ + TileIndex GetCrashSite() { return crash_site; } + + /** + * Clone the crashed vehicle and send it on its way again. + * @param depot the depot to build the vehicle in. + * @return True when the cloning succeeded. + * @note This function isn't implemented yet. + */ + bool CloneCrashedVehicle(TileIndex depot); + +private: + TileIndex crash_site; + VehicleID vehicle; +}; + +/** + * Event Subsidy Offered, indicating someone offered a subsidy. + */ +class AIEventSubsidyOffer : public AIEvent { +public: + static const char *GetClassName() { return "AIEventSubsidyOffer"; } + + /** + * @param subsidy_id The index of this subsidy in the _subsidies array. + */ + AIEventSubsidyOffer(SubsidyID subsidy_id) : + AIEvent(AI_ET_SUBSIDY_OFFER), + subsidy_id(subsidy_id) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventSubsidyOffer *Convert(AIEvent *instance) { return (AIEventSubsidyOffer *)instance; } + + /** + * Get the SubsidyID of the subsidy. + * @return The subsidy id. + */ + SubsidyID GetSubsidyID() { return subsidy_id; } + +private: + SubsidyID subsidy_id; +}; + +/** + * Event Subsidy Offer Expired, indicating a subsidy will no longer be awarded. + */ +class AIEventSubsidyOfferExpired : public AIEvent { +public: + static const char *GetClassName() { return "AIEventSubsidyOfferExpired"; } + + /** + * @param subsidy_id The index of this subsidy in the _subsidies array. + */ + AIEventSubsidyOfferExpired(SubsidyID subsidy_id) : + AIEvent(AI_ET_SUBSIDY_OFFER_EXPIRED), + subsidy_id(subsidy_id) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventSubsidyOfferExpired *Convert(AIEvent *instance) { return (AIEventSubsidyOfferExpired *)instance; } + + /** + * Get the SubsidyID of the subsidy. + * @return The subsidy id. + */ + SubsidyID GetSubsidyID() { return subsidy_id; } + +private: + SubsidyID subsidy_id; +}; + +/** + * Event Subidy Awarded, indicating a subsidy is awarded to some company. + */ +class AIEventSubsidyAwarded : public AIEvent { +public: + static const char *GetClassName() { return "AIEventSubsidyAwarded"; } + + /** + * @param subsidy_id The index of this subsidy in the _subsidies array. + */ + AIEventSubsidyAwarded(SubsidyID subsidy_id) : + AIEvent(AI_ET_SUBSIDY_AWARDED), + subsidy_id(subsidy_id) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventSubsidyAwarded *Convert(AIEvent *instance) { return (AIEventSubsidyAwarded *)instance; } + + /** + * Get the SubsidyID of the subsidy. + * @return The subsidy id. + */ + SubsidyID GetSubsidyID() { return subsidy_id; } + +private: + SubsidyID subsidy_id; +}; + +/** + * Event Subsidy Expired, indicating a route that was once subsidized no longer is. + */ +class AIEventSubsidyExpired : public AIEvent { +public: + static const char *GetClassName() { return "AIEventSubsidyExpired"; } + + /** + * @param subsidy_id The index of this subsidy in the _subsidies array. + */ + AIEventSubsidyExpired(SubsidyID subsidy_id) : + AIEvent(AI_ET_SUBSIDY_EXPIRED), + subsidy_id(subsidy_id) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventSubsidyExpired *Convert(AIEvent *instance) { return (AIEventSubsidyExpired *)instance; } + + /** + * Get the SubsidyID of the subsidy. + * @return The subsidy id. + */ + SubsidyID GetSubsidyID() { return subsidy_id; } + +private: + SubsidyID subsidy_id; +}; + +/** + * Event Engine Preview, indicating a manufacturer offer you to test a new engine. + * You can get the same information about the offered engine as a real user + * would see in the offer window. And you can also accept the offer. + */ +class AIEventEnginePreview : public AIEvent { +public: + static const char *GetClassName() { return "AIEventEnginePreview"; } + + /** + * @param engine The engine offered to test. + */ + AIEventEnginePreview(EngineID engine) : + AIEvent(AI_ET_ENGINE_PREVIEW), + engine(engine) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventEnginePreview *Convert(AIEvent *instance) { return (AIEventEnginePreview *)instance; } + + /** + * Get the name of the offered engine. + * @return The name the engine has. + */ + const char *GetName(); + + /** + * Get the cargo-type of the offered engine. In case it can transport 2 cargos, it + * returns the first. + * @return The cargo-type of the engine. + */ + CargoID GetCargoType(); + + /** + * Get the capacity of the offered engine. In case it can transport 2 cargos, it + * returns the first. + * @return The capacity of the engine. + */ + int32 GetCapacity(); + + /** + * Get the maximum speed of the offered engine. + * @return The maximum speed the engine has. + * @note The speed is in km/h. + */ + int32 GetMaxSpeed(); + + /** + * Get the new cost of the offered engine. + * @return The new cost the engine has. + */ + Money GetPrice(); + + /** + * Get the running cost of the offered engine. + * @return The running cost of the vehicle per year. + * @note Cost is per year; divide by 364 to get per day. + */ + Money GetRunningCost(); + + /** + * Get the type of the offered engine. + * @return The type the engine has. + */ + AIVehicle::VehicleType GetVehicleType(); + + /** + * Accept the engine preview. + * @return True when the accepting succeeded. + */ + bool AcceptPreview(); + +private: + EngineID engine; +}; + +/** + * Event Company New, indicating a new company has been created. + */ +class AIEventCompanyNew : public AIEvent { +public: + static const char *GetClassName() { return "AIEventCompanyNew"; } + + /** + * @param owner The new company. + */ + AIEventCompanyNew(Owner owner) : + AIEvent(AI_ET_COMPANY_NEW), + owner((AICompany::CompanyID)(byte)owner) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventCompanyNew *Convert(AIEvent *instance) { return (AIEventCompanyNew *)instance; } + + /** + * Get the CompanyID of the company that has been created. + * @return The CompanyID of the company. + */ + AICompany::CompanyID GetCompanyID() { return owner; } + +private: + AICompany::CompanyID owner; +}; + +/** + * Event Company In Trouble, indicating a company is in trouble and might go + * bankrupt soon. + */ +class AIEventCompanyInTrouble : public AIEvent { +public: + static const char *GetClassName() { return "AIEventCompanyInTrouble"; } + + /** + * @param owner The company that is in trouble. + */ + AIEventCompanyInTrouble(Owner owner) : + AIEvent(AI_ET_COMPANY_IN_TROUBLE), + owner((AICompany::CompanyID)(byte)owner) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventCompanyInTrouble *Convert(AIEvent *instance) { return (AIEventCompanyInTrouble *)instance; } + + /** + * Get the CompanyID of the company that is in trouble. + * @return The CompanyID of the company in trouble. + */ + AICompany::CompanyID GetCompanyID() { return owner; } + +private: + AICompany::CompanyID owner; +}; + +/** + * Event Company Merger, indicating a company has been bought by another + * company. + */ +class AIEventCompanyMerger : public AIEvent { +public: + static const char *GetClassName() { return "AIEventCompanyMerger"; } + + /** + * @param old_owner The company bought off. + * @param new_owner The company that bougth owner. + */ + AIEventCompanyMerger(Owner old_owner, Owner new_owner) : + AIEvent(AI_ET_COMPANY_MERGER), + old_owner((AICompany::CompanyID)(byte)old_owner), + new_owner((AICompany::CompanyID)(byte)new_owner) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventCompanyMerger *Convert(AIEvent *instance) { return (AIEventCompanyMerger *)instance; } + + /** + * Get the CompanyID of the company that has been bought. + * @return The CompanyID of the company that has been bought. + * @note: The value below is not valid anymore as CompanyID, and + * AICompany::ResolveCompanyID will return INVALID_COMPANY. It's + * only usefull if you're keeping track of company's yourself. + */ + AICompany::CompanyID GetOldCompanyID() { return old_owner; } + + /** + * Get the CompanyID of the new owner. + * @return The CompanyID of the new owner. + */ + AICompany::CompanyID GetNewCompanyID() { return new_owner; } + +private: + AICompany::CompanyID old_owner; + AICompany::CompanyID new_owner; +}; + +/** + * Event Company Bankrupt, indicating a company has gone bankrupt. + */ +class AIEventCompanyBankrupt : public AIEvent { +public: + static const char *GetClassName() { return "AIEventCompanyBankrupt"; } + + /** + * @param owner The company that has gone bankrupt. + */ + AIEventCompanyBankrupt(Owner owner) : + AIEvent(AI_ET_COMPANY_BANKRUPT), + owner((AICompany::CompanyID)(byte)owner) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventCompanyBankrupt *Convert(AIEvent *instance) { return (AIEventCompanyBankrupt *)instance; } + + /** + * Get the CompanyID of the company that has gone bankrupt. + * @return The CompanyID of the company that has gone bankrupt. + */ + AICompany::CompanyID GetCompanyID() { return owner; } + +private: + AICompany::CompanyID owner; +}; + +/** + * Event Vehicle Lost, indicating a vehicle can't find its way to its destination. + */ +class AIEventVehicleLost : public AIEvent { +public: + static const char *GetClassName() { return "AIEventVehicleLost"; } + + /** + * @param vehicle_id The vehicle that is lost. + */ + AIEventVehicleLost(VehicleID vehicle_id) : + AIEvent(AI_ET_VEHICLE_LOST), + vehicle_id(vehicle_id) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventVehicleLost *Convert(AIEvent *instance) { return (AIEventVehicleLost *)instance; } + + /** + * Get the VehicleID of the vehicle that is lost. + * @return The VehicleID of the vehicle that is lost. + */ + VehicleID GetVehicleID() { return vehicle_id; } + +private: + VehicleID vehicle_id; +}; + +/** + * Event VehicleWaitingInDepot, indicating a vehicle has arrived a depot and is now waiting there. + */ +class AIEventVehicleWaitingInDepot : public AIEvent { +public: + static const char *GetClassName() { return "AIEventVehicleWaitingInDepot"; } + + /** + * @param vehicle_id The vehicle that is waiting in a depot. + */ + AIEventVehicleWaitingInDepot(VehicleID vehicle_id) : + AIEvent(AI_ET_VEHICLE_WAITING_IN_DEPOT), + vehicle_id(vehicle_id) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventVehicleWaitingInDepot *Convert(AIEvent *instance) { return (AIEventVehicleWaitingInDepot *)instance; } + + /** + * Get the VehicleID of the vehicle that is waiting in a depot. + * @return The VehicleID of the vehicle that is waiting in a depot. + */ + VehicleID GetVehicleID() { return vehicle_id; } + +private: + VehicleID vehicle_id; +}; + +/** + * Event Vehicle Unprofitable, indicating a vehicle lost money last year. + */ +class AIEventVehicleUnprofitable : public AIEvent { +public: + static const char *GetClassName() { return "AIEventVehicleUnprofitable"; } + + /** + * @param vehicle_id The vehicle that was unprofitable. + */ + AIEventVehicleUnprofitable(VehicleID vehicle_id) : + AIEvent(AI_ET_VEHICLE_UNPROFITABLE), + vehicle_id(vehicle_id) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventVehicleUnprofitable *Convert(AIEvent *instance) { return (AIEventVehicleUnprofitable *)instance; } + + /** + * Get the VehicleID of the vehicle that lost money. + * @return The VehicleID of the vehicle that lost money. + */ + VehicleID GetVehicleID() { return vehicle_id; } + +private: + VehicleID vehicle_id; +}; + +/** + * Event Industry Open, indicating a new industry has been created. + */ +class AIEventIndustryOpen : public AIEvent { +public: + static const char *GetClassName() { return "AIEventIndustryOpen"; } + + /** + * @param industry_id The new industry. + */ + AIEventIndustryOpen(IndustryID industry_id) : + AIEvent(AI_ET_INDUSTRY_OPEN), + industry_id(industry_id) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventIndustryOpen *Convert(AIEvent *instance) { return (AIEventIndustryOpen *)instance; } + + /** + * Get the IndustryID of the new industry. + * @return The IndustryID of the industry. + */ + IndustryID GetIndustryID() { return industry_id; } + +private: + IndustryID industry_id; +}; + +/** + * Event Industry Close, indicating an industry is going to be closed. + */ +class AIEventIndustryClose : public AIEvent { +public: + static const char *GetClassName() { return "AIEventIndustryClose"; } + + /** + * @param industry_id The new industry. + */ + AIEventIndustryClose(IndustryID industry_id) : + AIEvent(AI_ET_INDUSTRY_CLOSE), + industry_id(industry_id) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventIndustryClose *Convert(AIEvent *instance) { return (AIEventIndustryClose *)instance; } + + /** + * Get the IndustryID of the closing industry. + * @return The IndustryID of the industry. + */ + IndustryID GetIndustryID() { return industry_id; } + +private: + IndustryID industry_id; +}; + +/** + * Event Engine Available, indicating a new engine is available. + */ +class AIEventEngineAvailable : public AIEvent { +public: + static const char *GetClassName() { return "AIEventEngineAvailable"; } + + /** + * @param engine The engine that is available. + */ + AIEventEngineAvailable(EngineID engine) : + AIEvent(AI_ET_ENGINE_AVAILABLE), + engine(engine) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventEngineAvailable *Convert(AIEvent *instance) { return (AIEventEngineAvailable *)instance; } + + /** + * Get the EngineID of the new engine. + * @return The EngineID of the new engine. + */ + EngineID GetEngineID() { return engine; } + +private: + EngineID engine; +}; + +/** + * Event Station First Vehicle, indicating a station has been visited by a vehicle for the first time. + */ +class AIEventStationFirstVehicle : public AIEvent { +public: + static const char *GetClassName() { return "AIEventStationFirstVehicle"; } + + /** + * @param station The station visited for the first time. + * @param vehicle The vehicle visiting the station. + */ + AIEventStationFirstVehicle(StationID station, VehicleID vehicle) : + AIEvent(AI_ET_STATION_FIRST_VEHICLE), + station(station), + vehicle(vehicle) + {} + + /** + * Convert an AIEvent to the real instance. + * @param instance The instance to convert. + * @return The converted instance. + */ + static AIEventStationFirstVehicle *Convert(AIEvent *instance) { return (AIEventStationFirstVehicle *)instance; } + + /** + * Get the StationID of the visited station. + * @return The StationID of the visited station. + */ + StationID GetStationID() { return station; } + + /** + * Get the VehicleID of the first vehicle. + * @return The VehicleID of the first vehicle. + */ + VehicleID GetVehicleID() { return vehicle; } + +private: + StationID station; + VehicleID vehicle; +}; + +#endif /* AI_EVENT_TYPES_HPP */ diff --git a/src/ai/api/ai_event_types.hpp.sq b/src/ai/api/ai_event_types.hpp.sq new file mode 100644 index 000000000..84d8b722b --- /dev/null +++ b/src/ai/api/ai_event_types.hpp.sq @@ -0,0 +1,393 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_event_types.hpp" + +namespace SQConvert { + /* Allow AIEventTest to be used as Squirrel parameter */ + template <> AIEventTest *GetParam(ForceType<AIEventTest *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventTest *)instance; } + template <> AIEventTest &GetParam(ForceType<AIEventTest &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventTest *)instance; } + template <> const AIEventTest *GetParam(ForceType<const AIEventTest *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventTest *)instance; } + template <> const AIEventTest &GetParam(ForceType<const AIEventTest &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventTest *)instance; } + template <> int Return<AIEventTest *>(HSQUIRRELVM vm, AIEventTest *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventTest", res, NULL, DefSQDestructorCallback<AIEventTest>); return 1; } +}; // namespace SQConvert + +void SQAIEventTest_Register(Squirrel *engine) { + DefSQClass <AIEventTest> SQAIEventTest("AIEventTest"); + SQAIEventTest.PreRegister(engine, "AIEvent"); + + SQAIEventTest.DefSQStaticMethod(engine, &AIEventTest::GetClassName, "GetClassName", 1, "x"); + SQAIEventTest.DefSQStaticMethod(engine, &AIEventTest::Convert, "Convert", 2, "xx"); + + SQAIEventTest.DefSQMethod(engine, &AIEventTest::GetTest, "GetTest", 1, "x"); + + SQAIEventTest.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventVehicleCrashed to be used as Squirrel parameter */ + template <> AIEventVehicleCrashed *GetParam(ForceType<AIEventVehicleCrashed *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventVehicleCrashed *)instance; } + template <> AIEventVehicleCrashed &GetParam(ForceType<AIEventVehicleCrashed &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventVehicleCrashed *)instance; } + template <> const AIEventVehicleCrashed *GetParam(ForceType<const AIEventVehicleCrashed *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventVehicleCrashed *)instance; } + template <> const AIEventVehicleCrashed &GetParam(ForceType<const AIEventVehicleCrashed &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventVehicleCrashed *)instance; } + template <> int Return<AIEventVehicleCrashed *>(HSQUIRRELVM vm, AIEventVehicleCrashed *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventVehicleCrashed", res, NULL, DefSQDestructorCallback<AIEventVehicleCrashed>); return 1; } +}; // namespace SQConvert + +void SQAIEventVehicleCrashed_Register(Squirrel *engine) { + DefSQClass <AIEventVehicleCrashed> SQAIEventVehicleCrashed("AIEventVehicleCrashed"); + SQAIEventVehicleCrashed.PreRegister(engine, "AIEvent"); + + SQAIEventVehicleCrashed.DefSQStaticMethod(engine, &AIEventVehicleCrashed::GetClassName, "GetClassName", 1, "x"); + SQAIEventVehicleCrashed.DefSQStaticMethod(engine, &AIEventVehicleCrashed::Convert, "Convert", 2, "xx"); + + SQAIEventVehicleCrashed.DefSQMethod(engine, &AIEventVehicleCrashed::GetVehicleID, "GetVehicleID", 1, "x"); + SQAIEventVehicleCrashed.DefSQMethod(engine, &AIEventVehicleCrashed::GetCrashSite, "GetCrashSite", 1, "x"); + SQAIEventVehicleCrashed.DefSQMethod(engine, &AIEventVehicleCrashed::CloneCrashedVehicle, "CloneCrashedVehicle", 2, "xi"); + + SQAIEventVehicleCrashed.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventSubsidyOffer to be used as Squirrel parameter */ + template <> AIEventSubsidyOffer *GetParam(ForceType<AIEventSubsidyOffer *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventSubsidyOffer *)instance; } + template <> AIEventSubsidyOffer &GetParam(ForceType<AIEventSubsidyOffer &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventSubsidyOffer *)instance; } + template <> const AIEventSubsidyOffer *GetParam(ForceType<const AIEventSubsidyOffer *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventSubsidyOffer *)instance; } + template <> const AIEventSubsidyOffer &GetParam(ForceType<const AIEventSubsidyOffer &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventSubsidyOffer *)instance; } + template <> int Return<AIEventSubsidyOffer *>(HSQUIRRELVM vm, AIEventSubsidyOffer *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventSubsidyOffer", res, NULL, DefSQDestructorCallback<AIEventSubsidyOffer>); return 1; } +}; // namespace SQConvert + +void SQAIEventSubsidyOffer_Register(Squirrel *engine) { + DefSQClass <AIEventSubsidyOffer> SQAIEventSubsidyOffer("AIEventSubsidyOffer"); + SQAIEventSubsidyOffer.PreRegister(engine, "AIEvent"); + + SQAIEventSubsidyOffer.DefSQStaticMethod(engine, &AIEventSubsidyOffer::GetClassName, "GetClassName", 1, "x"); + SQAIEventSubsidyOffer.DefSQStaticMethod(engine, &AIEventSubsidyOffer::Convert, "Convert", 2, "xx"); + + SQAIEventSubsidyOffer.DefSQMethod(engine, &AIEventSubsidyOffer::GetSubsidyID, "GetSubsidyID", 1, "x"); + + SQAIEventSubsidyOffer.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventSubsidyOfferExpired to be used as Squirrel parameter */ + template <> AIEventSubsidyOfferExpired *GetParam(ForceType<AIEventSubsidyOfferExpired *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventSubsidyOfferExpired *)instance; } + template <> AIEventSubsidyOfferExpired &GetParam(ForceType<AIEventSubsidyOfferExpired &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventSubsidyOfferExpired *)instance; } + template <> const AIEventSubsidyOfferExpired *GetParam(ForceType<const AIEventSubsidyOfferExpired *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventSubsidyOfferExpired *)instance; } + template <> const AIEventSubsidyOfferExpired &GetParam(ForceType<const AIEventSubsidyOfferExpired &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventSubsidyOfferExpired *)instance; } + template <> int Return<AIEventSubsidyOfferExpired *>(HSQUIRRELVM vm, AIEventSubsidyOfferExpired *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventSubsidyOfferExpired", res, NULL, DefSQDestructorCallback<AIEventSubsidyOfferExpired>); return 1; } +}; // namespace SQConvert + +void SQAIEventSubsidyOfferExpired_Register(Squirrel *engine) { + DefSQClass <AIEventSubsidyOfferExpired> SQAIEventSubsidyOfferExpired("AIEventSubsidyOfferExpired"); + SQAIEventSubsidyOfferExpired.PreRegister(engine, "AIEvent"); + + SQAIEventSubsidyOfferExpired.DefSQStaticMethod(engine, &AIEventSubsidyOfferExpired::GetClassName, "GetClassName", 1, "x"); + SQAIEventSubsidyOfferExpired.DefSQStaticMethod(engine, &AIEventSubsidyOfferExpired::Convert, "Convert", 2, "xx"); + + SQAIEventSubsidyOfferExpired.DefSQMethod(engine, &AIEventSubsidyOfferExpired::GetSubsidyID, "GetSubsidyID", 1, "x"); + + SQAIEventSubsidyOfferExpired.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventSubsidyAwarded to be used as Squirrel parameter */ + template <> AIEventSubsidyAwarded *GetParam(ForceType<AIEventSubsidyAwarded *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventSubsidyAwarded *)instance; } + template <> AIEventSubsidyAwarded &GetParam(ForceType<AIEventSubsidyAwarded &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventSubsidyAwarded *)instance; } + template <> const AIEventSubsidyAwarded *GetParam(ForceType<const AIEventSubsidyAwarded *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventSubsidyAwarded *)instance; } + template <> const AIEventSubsidyAwarded &GetParam(ForceType<const AIEventSubsidyAwarded &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventSubsidyAwarded *)instance; } + template <> int Return<AIEventSubsidyAwarded *>(HSQUIRRELVM vm, AIEventSubsidyAwarded *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventSubsidyAwarded", res, NULL, DefSQDestructorCallback<AIEventSubsidyAwarded>); return 1; } +}; // namespace SQConvert + +void SQAIEventSubsidyAwarded_Register(Squirrel *engine) { + DefSQClass <AIEventSubsidyAwarded> SQAIEventSubsidyAwarded("AIEventSubsidyAwarded"); + SQAIEventSubsidyAwarded.PreRegister(engine, "AIEvent"); + + SQAIEventSubsidyAwarded.DefSQStaticMethod(engine, &AIEventSubsidyAwarded::GetClassName, "GetClassName", 1, "x"); + SQAIEventSubsidyAwarded.DefSQStaticMethod(engine, &AIEventSubsidyAwarded::Convert, "Convert", 2, "xx"); + + SQAIEventSubsidyAwarded.DefSQMethod(engine, &AIEventSubsidyAwarded::GetSubsidyID, "GetSubsidyID", 1, "x"); + + SQAIEventSubsidyAwarded.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventSubsidyExpired to be used as Squirrel parameter */ + template <> AIEventSubsidyExpired *GetParam(ForceType<AIEventSubsidyExpired *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventSubsidyExpired *)instance; } + template <> AIEventSubsidyExpired &GetParam(ForceType<AIEventSubsidyExpired &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventSubsidyExpired *)instance; } + template <> const AIEventSubsidyExpired *GetParam(ForceType<const AIEventSubsidyExpired *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventSubsidyExpired *)instance; } + template <> const AIEventSubsidyExpired &GetParam(ForceType<const AIEventSubsidyExpired &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventSubsidyExpired *)instance; } + template <> int Return<AIEventSubsidyExpired *>(HSQUIRRELVM vm, AIEventSubsidyExpired *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventSubsidyExpired", res, NULL, DefSQDestructorCallback<AIEventSubsidyExpired>); return 1; } +}; // namespace SQConvert + +void SQAIEventSubsidyExpired_Register(Squirrel *engine) { + DefSQClass <AIEventSubsidyExpired> SQAIEventSubsidyExpired("AIEventSubsidyExpired"); + SQAIEventSubsidyExpired.PreRegister(engine, "AIEvent"); + + SQAIEventSubsidyExpired.DefSQStaticMethod(engine, &AIEventSubsidyExpired::GetClassName, "GetClassName", 1, "x"); + SQAIEventSubsidyExpired.DefSQStaticMethod(engine, &AIEventSubsidyExpired::Convert, "Convert", 2, "xx"); + + SQAIEventSubsidyExpired.DefSQMethod(engine, &AIEventSubsidyExpired::GetSubsidyID, "GetSubsidyID", 1, "x"); + + SQAIEventSubsidyExpired.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventEnginePreview to be used as Squirrel parameter */ + template <> AIEventEnginePreview *GetParam(ForceType<AIEventEnginePreview *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventEnginePreview *)instance; } + template <> AIEventEnginePreview &GetParam(ForceType<AIEventEnginePreview &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventEnginePreview *)instance; } + template <> const AIEventEnginePreview *GetParam(ForceType<const AIEventEnginePreview *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventEnginePreview *)instance; } + template <> const AIEventEnginePreview &GetParam(ForceType<const AIEventEnginePreview &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventEnginePreview *)instance; } + template <> int Return<AIEventEnginePreview *>(HSQUIRRELVM vm, AIEventEnginePreview *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventEnginePreview", res, NULL, DefSQDestructorCallback<AIEventEnginePreview>); return 1; } +}; // namespace SQConvert + +void SQAIEventEnginePreview_Register(Squirrel *engine) { + DefSQClass <AIEventEnginePreview> SQAIEventEnginePreview("AIEventEnginePreview"); + SQAIEventEnginePreview.PreRegister(engine, "AIEvent"); + + SQAIEventEnginePreview.DefSQStaticMethod(engine, &AIEventEnginePreview::GetClassName, "GetClassName", 1, "x"); + SQAIEventEnginePreview.DefSQStaticMethod(engine, &AIEventEnginePreview::Convert, "Convert", 2, "xx"); + + SQAIEventEnginePreview.DefSQMethod(engine, &AIEventEnginePreview::GetName, "GetName", 1, "x"); + SQAIEventEnginePreview.DefSQMethod(engine, &AIEventEnginePreview::GetCargoType, "GetCargoType", 1, "x"); + SQAIEventEnginePreview.DefSQMethod(engine, &AIEventEnginePreview::GetCapacity, "GetCapacity", 1, "x"); + SQAIEventEnginePreview.DefSQMethod(engine, &AIEventEnginePreview::GetMaxSpeed, "GetMaxSpeed", 1, "x"); + SQAIEventEnginePreview.DefSQMethod(engine, &AIEventEnginePreview::GetPrice, "GetPrice", 1, "x"); + SQAIEventEnginePreview.DefSQMethod(engine, &AIEventEnginePreview::GetRunningCost, "GetRunningCost", 1, "x"); + SQAIEventEnginePreview.DefSQMethod(engine, &AIEventEnginePreview::GetVehicleType, "GetVehicleType", 1, "x"); + SQAIEventEnginePreview.DefSQMethod(engine, &AIEventEnginePreview::AcceptPreview, "AcceptPreview", 1, "x"); + + SQAIEventEnginePreview.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventCompanyNew to be used as Squirrel parameter */ + template <> AIEventCompanyNew *GetParam(ForceType<AIEventCompanyNew *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventCompanyNew *)instance; } + template <> AIEventCompanyNew &GetParam(ForceType<AIEventCompanyNew &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyNew *)instance; } + template <> const AIEventCompanyNew *GetParam(ForceType<const AIEventCompanyNew *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventCompanyNew *)instance; } + template <> const AIEventCompanyNew &GetParam(ForceType<const AIEventCompanyNew &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyNew *)instance; } + template <> int Return<AIEventCompanyNew *>(HSQUIRRELVM vm, AIEventCompanyNew *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventCompanyNew", res, NULL, DefSQDestructorCallback<AIEventCompanyNew>); return 1; } +}; // namespace SQConvert + +void SQAIEventCompanyNew_Register(Squirrel *engine) { + DefSQClass <AIEventCompanyNew> SQAIEventCompanyNew("AIEventCompanyNew"); + SQAIEventCompanyNew.PreRegister(engine, "AIEvent"); + + SQAIEventCompanyNew.DefSQStaticMethod(engine, &AIEventCompanyNew::GetClassName, "GetClassName", 1, "x"); + SQAIEventCompanyNew.DefSQStaticMethod(engine, &AIEventCompanyNew::Convert, "Convert", 2, "xx"); + + SQAIEventCompanyNew.DefSQMethod(engine, &AIEventCompanyNew::GetCompanyID, "GetCompanyID", 1, "x"); + + SQAIEventCompanyNew.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventCompanyInTrouble to be used as Squirrel parameter */ + template <> AIEventCompanyInTrouble *GetParam(ForceType<AIEventCompanyInTrouble *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventCompanyInTrouble *)instance; } + template <> AIEventCompanyInTrouble &GetParam(ForceType<AIEventCompanyInTrouble &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyInTrouble *)instance; } + template <> const AIEventCompanyInTrouble *GetParam(ForceType<const AIEventCompanyInTrouble *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventCompanyInTrouble *)instance; } + template <> const AIEventCompanyInTrouble &GetParam(ForceType<const AIEventCompanyInTrouble &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyInTrouble *)instance; } + template <> int Return<AIEventCompanyInTrouble *>(HSQUIRRELVM vm, AIEventCompanyInTrouble *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventCompanyInTrouble", res, NULL, DefSQDestructorCallback<AIEventCompanyInTrouble>); return 1; } +}; // namespace SQConvert + +void SQAIEventCompanyInTrouble_Register(Squirrel *engine) { + DefSQClass <AIEventCompanyInTrouble> SQAIEventCompanyInTrouble("AIEventCompanyInTrouble"); + SQAIEventCompanyInTrouble.PreRegister(engine, "AIEvent"); + + SQAIEventCompanyInTrouble.DefSQStaticMethod(engine, &AIEventCompanyInTrouble::GetClassName, "GetClassName", 1, "x"); + SQAIEventCompanyInTrouble.DefSQStaticMethod(engine, &AIEventCompanyInTrouble::Convert, "Convert", 2, "xx"); + + SQAIEventCompanyInTrouble.DefSQMethod(engine, &AIEventCompanyInTrouble::GetCompanyID, "GetCompanyID", 1, "x"); + + SQAIEventCompanyInTrouble.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventCompanyMerger to be used as Squirrel parameter */ + template <> AIEventCompanyMerger *GetParam(ForceType<AIEventCompanyMerger *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventCompanyMerger *)instance; } + template <> AIEventCompanyMerger &GetParam(ForceType<AIEventCompanyMerger &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyMerger *)instance; } + template <> const AIEventCompanyMerger *GetParam(ForceType<const AIEventCompanyMerger *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventCompanyMerger *)instance; } + template <> const AIEventCompanyMerger &GetParam(ForceType<const AIEventCompanyMerger &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyMerger *)instance; } + template <> int Return<AIEventCompanyMerger *>(HSQUIRRELVM vm, AIEventCompanyMerger *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventCompanyMerger", res, NULL, DefSQDestructorCallback<AIEventCompanyMerger>); return 1; } +}; // namespace SQConvert + +void SQAIEventCompanyMerger_Register(Squirrel *engine) { + DefSQClass <AIEventCompanyMerger> SQAIEventCompanyMerger("AIEventCompanyMerger"); + SQAIEventCompanyMerger.PreRegister(engine, "AIEvent"); + + SQAIEventCompanyMerger.DefSQStaticMethod(engine, &AIEventCompanyMerger::GetClassName, "GetClassName", 1, "x"); + SQAIEventCompanyMerger.DefSQStaticMethod(engine, &AIEventCompanyMerger::Convert, "Convert", 2, "xx"); + + SQAIEventCompanyMerger.DefSQMethod(engine, &AIEventCompanyMerger::GetOldCompanyID, "GetOldCompanyID", 1, "x"); + SQAIEventCompanyMerger.DefSQMethod(engine, &AIEventCompanyMerger::GetNewCompanyID, "GetNewCompanyID", 1, "x"); + + SQAIEventCompanyMerger.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventCompanyBankrupt to be used as Squirrel parameter */ + template <> AIEventCompanyBankrupt *GetParam(ForceType<AIEventCompanyBankrupt *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventCompanyBankrupt *)instance; } + template <> AIEventCompanyBankrupt &GetParam(ForceType<AIEventCompanyBankrupt &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyBankrupt *)instance; } + template <> const AIEventCompanyBankrupt *GetParam(ForceType<const AIEventCompanyBankrupt *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventCompanyBankrupt *)instance; } + template <> const AIEventCompanyBankrupt &GetParam(ForceType<const AIEventCompanyBankrupt &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyBankrupt *)instance; } + template <> int Return<AIEventCompanyBankrupt *>(HSQUIRRELVM vm, AIEventCompanyBankrupt *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventCompanyBankrupt", res, NULL, DefSQDestructorCallback<AIEventCompanyBankrupt>); return 1; } +}; // namespace SQConvert + +void SQAIEventCompanyBankrupt_Register(Squirrel *engine) { + DefSQClass <AIEventCompanyBankrupt> SQAIEventCompanyBankrupt("AIEventCompanyBankrupt"); + SQAIEventCompanyBankrupt.PreRegister(engine, "AIEvent"); + + SQAIEventCompanyBankrupt.DefSQStaticMethod(engine, &AIEventCompanyBankrupt::GetClassName, "GetClassName", 1, "x"); + SQAIEventCompanyBankrupt.DefSQStaticMethod(engine, &AIEventCompanyBankrupt::Convert, "Convert", 2, "xx"); + + SQAIEventCompanyBankrupt.DefSQMethod(engine, &AIEventCompanyBankrupt::GetCompanyID, "GetCompanyID", 1, "x"); + + SQAIEventCompanyBankrupt.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventVehicleLost to be used as Squirrel parameter */ + template <> AIEventVehicleLost *GetParam(ForceType<AIEventVehicleLost *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventVehicleLost *)instance; } + template <> AIEventVehicleLost &GetParam(ForceType<AIEventVehicleLost &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventVehicleLost *)instance; } + template <> const AIEventVehicleLost *GetParam(ForceType<const AIEventVehicleLost *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventVehicleLost *)instance; } + template <> const AIEventVehicleLost &GetParam(ForceType<const AIEventVehicleLost &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventVehicleLost *)instance; } + template <> int Return<AIEventVehicleLost *>(HSQUIRRELVM vm, AIEventVehicleLost *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventVehicleLost", res, NULL, DefSQDestructorCallback<AIEventVehicleLost>); return 1; } +}; // namespace SQConvert + +void SQAIEventVehicleLost_Register(Squirrel *engine) { + DefSQClass <AIEventVehicleLost> SQAIEventVehicleLost("AIEventVehicleLost"); + SQAIEventVehicleLost.PreRegister(engine, "AIEvent"); + + SQAIEventVehicleLost.DefSQStaticMethod(engine, &AIEventVehicleLost::GetClassName, "GetClassName", 1, "x"); + SQAIEventVehicleLost.DefSQStaticMethod(engine, &AIEventVehicleLost::Convert, "Convert", 2, "xx"); + + SQAIEventVehicleLost.DefSQMethod(engine, &AIEventVehicleLost::GetVehicleID, "GetVehicleID", 1, "x"); + + SQAIEventVehicleLost.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventVehicleWaitingInDepot to be used as Squirrel parameter */ + template <> AIEventVehicleWaitingInDepot *GetParam(ForceType<AIEventVehicleWaitingInDepot *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventVehicleWaitingInDepot *)instance; } + template <> AIEventVehicleWaitingInDepot &GetParam(ForceType<AIEventVehicleWaitingInDepot &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventVehicleWaitingInDepot *)instance; } + template <> const AIEventVehicleWaitingInDepot *GetParam(ForceType<const AIEventVehicleWaitingInDepot *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventVehicleWaitingInDepot *)instance; } + template <> const AIEventVehicleWaitingInDepot &GetParam(ForceType<const AIEventVehicleWaitingInDepot &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventVehicleWaitingInDepot *)instance; } + template <> int Return<AIEventVehicleWaitingInDepot *>(HSQUIRRELVM vm, AIEventVehicleWaitingInDepot *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventVehicleWaitingInDepot", res, NULL, DefSQDestructorCallback<AIEventVehicleWaitingInDepot>); return 1; } +}; // namespace SQConvert + +void SQAIEventVehicleWaitingInDepot_Register(Squirrel *engine) { + DefSQClass <AIEventVehicleWaitingInDepot> SQAIEventVehicleWaitingInDepot("AIEventVehicleWaitingInDepot"); + SQAIEventVehicleWaitingInDepot.PreRegister(engine, "AIEvent"); + + SQAIEventVehicleWaitingInDepot.DefSQStaticMethod(engine, &AIEventVehicleWaitingInDepot::GetClassName, "GetClassName", 1, "x"); + SQAIEventVehicleWaitingInDepot.DefSQStaticMethod(engine, &AIEventVehicleWaitingInDepot::Convert, "Convert", 2, "xx"); + + SQAIEventVehicleWaitingInDepot.DefSQMethod(engine, &AIEventVehicleWaitingInDepot::GetVehicleID, "GetVehicleID", 1, "x"); + + SQAIEventVehicleWaitingInDepot.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventVehicleUnprofitable to be used as Squirrel parameter */ + template <> AIEventVehicleUnprofitable *GetParam(ForceType<AIEventVehicleUnprofitable *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventVehicleUnprofitable *)instance; } + template <> AIEventVehicleUnprofitable &GetParam(ForceType<AIEventVehicleUnprofitable &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventVehicleUnprofitable *)instance; } + template <> const AIEventVehicleUnprofitable *GetParam(ForceType<const AIEventVehicleUnprofitable *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventVehicleUnprofitable *)instance; } + template <> const AIEventVehicleUnprofitable &GetParam(ForceType<const AIEventVehicleUnprofitable &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventVehicleUnprofitable *)instance; } + template <> int Return<AIEventVehicleUnprofitable *>(HSQUIRRELVM vm, AIEventVehicleUnprofitable *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventVehicleUnprofitable", res, NULL, DefSQDestructorCallback<AIEventVehicleUnprofitable>); return 1; } +}; // namespace SQConvert + +void SQAIEventVehicleUnprofitable_Register(Squirrel *engine) { + DefSQClass <AIEventVehicleUnprofitable> SQAIEventVehicleUnprofitable("AIEventVehicleUnprofitable"); + SQAIEventVehicleUnprofitable.PreRegister(engine, "AIEvent"); + + SQAIEventVehicleUnprofitable.DefSQStaticMethod(engine, &AIEventVehicleUnprofitable::GetClassName, "GetClassName", 1, "x"); + SQAIEventVehicleUnprofitable.DefSQStaticMethod(engine, &AIEventVehicleUnprofitable::Convert, "Convert", 2, "xx"); + + SQAIEventVehicleUnprofitable.DefSQMethod(engine, &AIEventVehicleUnprofitable::GetVehicleID, "GetVehicleID", 1, "x"); + + SQAIEventVehicleUnprofitable.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventIndustryOpen to be used as Squirrel parameter */ + template <> AIEventIndustryOpen *GetParam(ForceType<AIEventIndustryOpen *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventIndustryOpen *)instance; } + template <> AIEventIndustryOpen &GetParam(ForceType<AIEventIndustryOpen &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventIndustryOpen *)instance; } + template <> const AIEventIndustryOpen *GetParam(ForceType<const AIEventIndustryOpen *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventIndustryOpen *)instance; } + template <> const AIEventIndustryOpen &GetParam(ForceType<const AIEventIndustryOpen &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventIndustryOpen *)instance; } + template <> int Return<AIEventIndustryOpen *>(HSQUIRRELVM vm, AIEventIndustryOpen *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventIndustryOpen", res, NULL, DefSQDestructorCallback<AIEventIndustryOpen>); return 1; } +}; // namespace SQConvert + +void SQAIEventIndustryOpen_Register(Squirrel *engine) { + DefSQClass <AIEventIndustryOpen> SQAIEventIndustryOpen("AIEventIndustryOpen"); + SQAIEventIndustryOpen.PreRegister(engine, "AIEvent"); + + SQAIEventIndustryOpen.DefSQStaticMethod(engine, &AIEventIndustryOpen::GetClassName, "GetClassName", 1, "x"); + SQAIEventIndustryOpen.DefSQStaticMethod(engine, &AIEventIndustryOpen::Convert, "Convert", 2, "xx"); + + SQAIEventIndustryOpen.DefSQMethod(engine, &AIEventIndustryOpen::GetIndustryID, "GetIndustryID", 1, "x"); + + SQAIEventIndustryOpen.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventIndustryClose to be used as Squirrel parameter */ + template <> AIEventIndustryClose *GetParam(ForceType<AIEventIndustryClose *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventIndustryClose *)instance; } + template <> AIEventIndustryClose &GetParam(ForceType<AIEventIndustryClose &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventIndustryClose *)instance; } + template <> const AIEventIndustryClose *GetParam(ForceType<const AIEventIndustryClose *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventIndustryClose *)instance; } + template <> const AIEventIndustryClose &GetParam(ForceType<const AIEventIndustryClose &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventIndustryClose *)instance; } + template <> int Return<AIEventIndustryClose *>(HSQUIRRELVM vm, AIEventIndustryClose *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventIndustryClose", res, NULL, DefSQDestructorCallback<AIEventIndustryClose>); return 1; } +}; // namespace SQConvert + +void SQAIEventIndustryClose_Register(Squirrel *engine) { + DefSQClass <AIEventIndustryClose> SQAIEventIndustryClose("AIEventIndustryClose"); + SQAIEventIndustryClose.PreRegister(engine, "AIEvent"); + + SQAIEventIndustryClose.DefSQStaticMethod(engine, &AIEventIndustryClose::GetClassName, "GetClassName", 1, "x"); + SQAIEventIndustryClose.DefSQStaticMethod(engine, &AIEventIndustryClose::Convert, "Convert", 2, "xx"); + + SQAIEventIndustryClose.DefSQMethod(engine, &AIEventIndustryClose::GetIndustryID, "GetIndustryID", 1, "x"); + + SQAIEventIndustryClose.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventEngineAvailable to be used as Squirrel parameter */ + template <> AIEventEngineAvailable *GetParam(ForceType<AIEventEngineAvailable *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventEngineAvailable *)instance; } + template <> AIEventEngineAvailable &GetParam(ForceType<AIEventEngineAvailable &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventEngineAvailable *)instance; } + template <> const AIEventEngineAvailable *GetParam(ForceType<const AIEventEngineAvailable *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventEngineAvailable *)instance; } + template <> const AIEventEngineAvailable &GetParam(ForceType<const AIEventEngineAvailable &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventEngineAvailable *)instance; } + template <> int Return<AIEventEngineAvailable *>(HSQUIRRELVM vm, AIEventEngineAvailable *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventEngineAvailable", res, NULL, DefSQDestructorCallback<AIEventEngineAvailable>); return 1; } +}; // namespace SQConvert + +void SQAIEventEngineAvailable_Register(Squirrel *engine) { + DefSQClass <AIEventEngineAvailable> SQAIEventEngineAvailable("AIEventEngineAvailable"); + SQAIEventEngineAvailable.PreRegister(engine, "AIEvent"); + + SQAIEventEngineAvailable.DefSQStaticMethod(engine, &AIEventEngineAvailable::GetClassName, "GetClassName", 1, "x"); + SQAIEventEngineAvailable.DefSQStaticMethod(engine, &AIEventEngineAvailable::Convert, "Convert", 2, "xx"); + + SQAIEventEngineAvailable.DefSQMethod(engine, &AIEventEngineAvailable::GetEngineID, "GetEngineID", 1, "x"); + + SQAIEventEngineAvailable.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIEventStationFirstVehicle to be used as Squirrel parameter */ + template <> AIEventStationFirstVehicle *GetParam(ForceType<AIEventStationFirstVehicle *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventStationFirstVehicle *)instance; } + template <> AIEventStationFirstVehicle &GetParam(ForceType<AIEventStationFirstVehicle &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventStationFirstVehicle *)instance; } + template <> const AIEventStationFirstVehicle *GetParam(ForceType<const AIEventStationFirstVehicle *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIEventStationFirstVehicle *)instance; } + template <> const AIEventStationFirstVehicle &GetParam(ForceType<const AIEventStationFirstVehicle &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventStationFirstVehicle *)instance; } + template <> int Return<AIEventStationFirstVehicle *>(HSQUIRRELVM vm, AIEventStationFirstVehicle *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventStationFirstVehicle", res, NULL, DefSQDestructorCallback<AIEventStationFirstVehicle>); return 1; } +}; // namespace SQConvert + +void SQAIEventStationFirstVehicle_Register(Squirrel *engine) { + DefSQClass <AIEventStationFirstVehicle> SQAIEventStationFirstVehicle("AIEventStationFirstVehicle"); + SQAIEventStationFirstVehicle.PreRegister(engine, "AIEvent"); + + SQAIEventStationFirstVehicle.DefSQStaticMethod(engine, &AIEventStationFirstVehicle::GetClassName, "GetClassName", 1, "x"); + SQAIEventStationFirstVehicle.DefSQStaticMethod(engine, &AIEventStationFirstVehicle::Convert, "Convert", 2, "xx"); + + SQAIEventStationFirstVehicle.DefSQMethod(engine, &AIEventStationFirstVehicle::GetStationID, "GetStationID", 1, "x"); + SQAIEventStationFirstVehicle.DefSQMethod(engine, &AIEventStationFirstVehicle::GetVehicleID, "GetVehicleID", 1, "x"); + + SQAIEventStationFirstVehicle.PostRegister(engine); +} diff --git a/src/ai/api/ai_execmode.cpp b/src/ai/api/ai_execmode.cpp new file mode 100644 index 000000000..941718bee --- /dev/null +++ b/src/ai/api/ai_execmode.cpp @@ -0,0 +1,26 @@ +/* $Id$ */ + +/** @file ai_execmode.cpp Implementation of AIExecMode. */ + +#include "ai_execmode.hpp" +#include "../../command_type.h" + +bool AIExecMode::ModeProc(TileIndex tile, uint32 p1, uint32 p2, uint procc, CommandCost costs) +{ + /* In execution mode we only return 'true', telling the DoCommand it + * should continue with the real execution of the command. */ + return true; +} + +AIExecMode::AIExecMode() +{ + this->last_mode = this->GetDoCommandMode(); + this->last_instance = this->GetDoCommandModeInstance(); + this->SetDoCommandMode(&AIExecMode::ModeProc, this); +} + +AIExecMode::~AIExecMode() +{ + assert(this->GetDoCommandModeInstance() == this); + this->SetDoCommandMode(this->last_mode, this->last_instance); +} diff --git a/src/ai/api/ai_execmode.hpp b/src/ai/api/ai_execmode.hpp new file mode 100644 index 000000000..4f6a47bc4 --- /dev/null +++ b/src/ai/api/ai_execmode.hpp @@ -0,0 +1,46 @@ +/* $Id$ */ + +/** @file ai_execmode.hpp Switch the AI to Execute Mode. */ + +#ifndef AI_EXECMODE_HPP +#define AI_EXECMODE_HPP + +#include "ai_object.hpp" + +/** + * Class to switch current mode to Execute Mode. + * If you create an instance of this class, the mode will be switched to + * Execute. The original mode is stored and recovered from when ever the + * instance is destroyed. + * In Execute mode all commands you do are executed for real. + */ +class AIExecMode : public AIObject { +public: + static const char *GetClassName() { return "AIExecMode"; } + +private: + AIModeProc *last_mode; + AIObject *last_instance; + +protected: + /** + * The callback proc for Execute mode. + */ + static bool ModeProc(TileIndex tile, uint32 p1, uint32 p2, uint procc, CommandCost costs); + +public: + /** + * Creating instance of this class switches the build mode to Execute. + * @note When the instance is destroyed, he restores the mode that was + * current when the instance was created! + */ + AIExecMode(); + + /** + * Destroying this instance reset the building mode to the mode it was + * in when the instance was created. + */ + ~AIExecMode(); +}; + +#endif /* AI_EXECMODE_HPP */ diff --git a/src/ai/api/ai_execmode.hpp.sq b/src/ai/api/ai_execmode.hpp.sq new file mode 100644 index 000000000..de78e9b6b --- /dev/null +++ b/src/ai/api/ai_execmode.hpp.sq @@ -0,0 +1,23 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_execmode.hpp" + +namespace SQConvert { + /* Allow AIExecMode to be used as Squirrel parameter */ + template <> AIExecMode *GetParam(ForceType<AIExecMode *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIExecMode *)instance; } + template <> AIExecMode &GetParam(ForceType<AIExecMode &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIExecMode *)instance; } + template <> const AIExecMode *GetParam(ForceType<const AIExecMode *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIExecMode *)instance; } + template <> const AIExecMode &GetParam(ForceType<const AIExecMode &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIExecMode *)instance; } + template <> int Return<AIExecMode *>(HSQUIRRELVM vm, AIExecMode *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIExecMode", res, NULL, DefSQDestructorCallback<AIExecMode>); return 1; } +}; // namespace SQConvert + +void SQAIExecMode_Register(Squirrel *engine) { + DefSQClass <AIExecMode> SQAIExecMode("AIExecMode"); + SQAIExecMode.PreRegister(engine); + SQAIExecMode.AddConstructor<void (AIExecMode::*)(), 1>(engine, "x"); + + SQAIExecMode.DefSQStaticMethod(engine, &AIExecMode::GetClassName, "GetClassName", 1, "x"); + + SQAIExecMode.PostRegister(engine); +} diff --git a/src/ai/api/ai_gamesettings.cpp b/src/ai/api/ai_gamesettings.cpp new file mode 100644 index 000000000..81b187d73 --- /dev/null +++ b/src/ai/api/ai_gamesettings.cpp @@ -0,0 +1,38 @@ +/* $Id$ */ + +/** @file ai_gamesettings.cpp Implementation of AIGameSettings. */ + +#include "ai_gamesettings.hpp" +#include "../../settings_internal.h" +#include "../../saveload/saveload.h" + +/* static */ bool AIGameSettings::IsValid(const char *setting) +{ + uint i; + const SettingDesc *sd = GetPatchFromName(setting, &i); + return sd != NULL && sd->desc.cmd != SDT_STRING; +} + +/* static */ int32 AIGameSettings::GetValue(const char *setting) +{ + if (!IsValid(setting)) return -1; + + uint i; + const SettingDesc *sd = GetPatchFromName(setting, &i); + + void *ptr = GetVariableAddress(&_settings_game, &sd->save); + if (sd->desc.cmd == SDT_BOOLX) return *(bool*)ptr; + + return (int32)ReadValue(ptr, sd->save.conv); +} + +/* static */ bool AIGameSettings::IsDisabledVehicleType(AIVehicle::VehicleType vehicle_type) +{ + switch (vehicle_type) { + case AIVehicle::VEHICLE_RAIL: return _settings_game.ai.ai_disable_veh_train; + case AIVehicle::VEHICLE_ROAD: return _settings_game.ai.ai_disable_veh_roadveh; + case AIVehicle::VEHICLE_WATER: return _settings_game.ai.ai_disable_veh_ship; + case AIVehicle::VEHICLE_AIR: return _settings_game.ai.ai_disable_veh_aircraft; + default: return true; + } +} diff --git a/src/ai/api/ai_gamesettings.hpp b/src/ai/api/ai_gamesettings.hpp new file mode 100644 index 000000000..67c8d964e --- /dev/null +++ b/src/ai/api/ai_gamesettings.hpp @@ -0,0 +1,67 @@ +/* $Id$ */ + +/** @file ai_gamesettings.hpp Everything to read game settings. */ + +#ifndef AI_GAMESETTINGS_HPP +#define AI_GAMESETTINGS_HPP + +#include "ai_object.hpp" +#include "ai_vehicle.hpp" + +/** + * Class that handles all game settings related functions. + * + * @note AIGameSettings::IsValid and AIGameSettings::GetValue are functions + * that rely on the settings as OpenTTD stores them in savegame and + * openttd.cfg. No guarantees can be given on the long term validity, + * consistency and stability of the names, values and value ranges. + * Using these settings can be dangerous and could cause issues in + * future versions. To make sure that a setting still exists in the + * current version you have to run AIGameSettings::IsValid before + * accessing it. + * + * @note The names of the setting for AIGameSettings::IsValid and + * AIGameSettings::GetValue are the same ones as those that are shown by + * the list_patches command in the in-game console. Settings that are + * string based are NOT supported and AIGAmeSettings::IsValid will return + * false for them. These settings will not be supported either because + * they have no relevance for the AI (default client names, server IPs, + * etc.). + */ +class AIGameSettings : public AIObject { +public: + static const char *GetClassName() { return "AIGameSettings"; } + + /** + * Is the given game setting a valid setting for this instance of OpenTTD? + * @param setting The setting to check for existence. + * @warning Results of this function are not governed by the API. This means + * that a setting that previously existed can be gone or has + * changed it's name. + * @note Results achieved in the past offer no gurantee for the future. + * @return True if and only if the setting is valid. + */ + static bool IsValid(const char *setting); + + /** + * Gets the value of the game setting. + * @param setting The setting to get the value of. + * @pre IsValid(setting). + * @warning Results of this function are not governed by the API. This means + * that the value of settings may be out of the expected range. It + * also means that a setting that previously existed can be gone or + * has changed it's name/characteristics. + * @note Results achieved in the past offer no gurantee for the future. + * @return The value for the setting. + */ + static int32 GetValue(const char *setting); + + /** + * Checks whether the given vehicle-type is disabled for AIs. + * @param vehicle_type The vehicle-type to check. + * @return True if the vehicle-type is disabled. + */ + static bool IsDisabledVehicleType(AIVehicle::VehicleType vehicle_type); +}; + +#endif /* AI_GAMESETTINGS_HPP */ diff --git a/src/ai/api/ai_gamesettings.hpp.sq b/src/ai/api/ai_gamesettings.hpp.sq new file mode 100644 index 000000000..e21812c08 --- /dev/null +++ b/src/ai/api/ai_gamesettings.hpp.sq @@ -0,0 +1,26 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_gamesettings.hpp" + +namespace SQConvert { + /* Allow AIGameSettings to be used as Squirrel parameter */ + template <> AIGameSettings *GetParam(ForceType<AIGameSettings *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIGameSettings *)instance; } + template <> AIGameSettings &GetParam(ForceType<AIGameSettings &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIGameSettings *)instance; } + template <> const AIGameSettings *GetParam(ForceType<const AIGameSettings *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIGameSettings *)instance; } + template <> const AIGameSettings &GetParam(ForceType<const AIGameSettings &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIGameSettings *)instance; } + template <> int Return<AIGameSettings *>(HSQUIRRELVM vm, AIGameSettings *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIGameSettings", res, NULL, DefSQDestructorCallback<AIGameSettings>); return 1; } +}; // namespace SQConvert + +void SQAIGameSettings_Register(Squirrel *engine) { + DefSQClass <AIGameSettings> SQAIGameSettings("AIGameSettings"); + SQAIGameSettings.PreRegister(engine); + SQAIGameSettings.AddConstructor<void (AIGameSettings::*)(), 1>(engine, "x"); + + SQAIGameSettings.DefSQStaticMethod(engine, &AIGameSettings::GetClassName, "GetClassName", 1, "x"); + SQAIGameSettings.DefSQStaticMethod(engine, &AIGameSettings::IsValid, "IsValid", 2, "xs"); + SQAIGameSettings.DefSQStaticMethod(engine, &AIGameSettings::GetValue, "GetValue", 2, "xs"); + SQAIGameSettings.DefSQStaticMethod(engine, &AIGameSettings::IsDisabledVehicleType, "IsDisabledVehicleType", 2, "xi"); + + SQAIGameSettings.PostRegister(engine); +} diff --git a/src/ai/api/ai_group.cpp b/src/ai/api/ai_group.cpp new file mode 100644 index 000000000..a6365450b --- /dev/null +++ b/src/ai/api/ai_group.cpp @@ -0,0 +1,128 @@ +/* $Id$ */ + +/** @file ai_group.cpp Implementation of AIGroup. */ + +#include "ai_group.hpp" +#include "ai_vehicle.hpp" +#include "ai_engine.hpp" +#include "../ai_instance.hpp" +#include "../../openttd.h" +#include "../../company_func.h" +#include "../../group.h" +#include "../../string_func.h" +#include "../../strings_func.h" +#include "../../core/alloc_func.hpp" +#include "../../command_func.h" +#include "../../autoreplace_func.h" +#include "table/strings.h" + +/* static */ bool AIGroup::IsValidGroup(GroupID group_id) +{ + return ::IsValidGroupID(group_id) && ::GetGroup(group_id)->owner == _current_company; +} + +/* static */ AIGroup::GroupID AIGroup::CreateGroup(AIVehicle::VehicleType vehicle_type) +{ + if (!AIObject::DoCommand(0, (::VehicleType)vehicle_type, 0, CMD_CREATE_GROUP, NULL, &AIInstance::DoCommandReturnGroupID)) return INVALID_GROUP; + + /* In case of test-mode, we return GroupID 0 */ + return (AIGroup::GroupID)0; +} + +/* static */ bool AIGroup::DeleteGroup(GroupID group_id) +{ + EnforcePrecondition(false, IsValidGroup(group_id)); + + return AIObject::DoCommand(0, group_id, 0, CMD_DELETE_GROUP); +} + +/* static */ AIVehicle::VehicleType AIGroup::GetVehicleType(GroupID group_id) +{ + if (!IsValidGroup(group_id)) return AIVehicle::VEHICLE_INVALID; + + return (AIVehicle::VehicleType)((::VehicleType)::GetGroup(group_id)->vehicle_type); +} + +/* static */ bool AIGroup::SetName(GroupID group_id, const char *name) +{ + EnforcePrecondition(false, IsValidGroup(group_id)); + EnforcePrecondition(false, !::StrEmpty(name)); + EnforcePreconditionCustomError(false, ::strlen(name) < MAX_LENGTH_GROUP_NAME_BYTES, AIError::ERR_PRECONDITION_STRING_TOO_LONG); + + return AIObject::DoCommand(0, group_id, 0, CMD_RENAME_GROUP, name); +} + +/* static */ const char *AIGroup::GetName(GroupID group_id) +{ + if (!IsValidGroup(group_id)) return NULL; + + static const int len = 64; + char *group_name = MallocT<char>(len); + + ::SetDParam(0, group_id); + ::GetString(group_name, STR_GROUP_NAME, &group_name[len - 1]); + return group_name; +} + +/* static */ bool AIGroup::EnableAutoReplaceProtection(GroupID group_id, bool enable) +{ + EnforcePrecondition(false, IsValidGroup(group_id)); + + return AIObject::DoCommand(0, group_id, enable ? 1 : 0, CMD_SET_GROUP_REPLACE_PROTECTION); +} + +/* static */ bool AIGroup::GetAutoReplaceProtection(GroupID group_id) +{ + if (!IsValidGroup(group_id)) return false; + + return ::GetGroup(group_id)->replace_protection; +} + +/* static */ int32 AIGroup::GetNumEngines(GroupID group_id, EngineID engine_id) +{ + if (!IsValidGroup(group_id) && group_id != DEFAULT_GROUP && group_id != ALL_GROUP) return -1; + + return GetGroupNumEngines(_current_company, group_id, engine_id); +} + +/* static */ bool AIGroup::MoveVehicle(GroupID group_id, VehicleID vehicle_id) +{ + EnforcePrecondition(false, IsValidGroup(group_id) || group_id == DEFAULT_GROUP); + EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id)); + + return AIObject::DoCommand(0, group_id, vehicle_id, CMD_ADD_VEHICLE_GROUP); +} + +/* static */ bool AIGroup::EnableWagonRemoval(bool enable_removal) +{ + if (HasWagonRemoval() == enable_removal) return true; + + return AIObject::DoCommand(0, 5, enable_removal ? 1 : 0, CMD_SET_AUTOREPLACE); +} + +/* static */ bool AIGroup::HasWagonRemoval() +{ + return ::GetCompany(_current_company)->renew_keep_length; +} + +/* static */ bool AIGroup::SetAutoReplace(GroupID group_id, EngineID engine_id_old, EngineID engine_id_new) +{ + EnforcePrecondition(false, IsValidGroup(group_id) || group_id == ALL_GROUP); + EnforcePrecondition(false, AIEngine::IsValidEngine(engine_id_new)); + + return AIObject::DoCommand(0, 3 | (group_id << 16), (engine_id_new << 16) | engine_id_old, CMD_SET_AUTOREPLACE); +} + +/* static */ EngineID AIGroup::GetEngineReplacement(GroupID group_id, EngineID engine_id) +{ + if (!IsValidGroup(group_id) && group_id != ALL_GROUP) return ::INVALID_ENGINE; + + return ::EngineReplacementForCompany(GetCompany(_current_company), engine_id, group_id); +} + +/* static */ bool AIGroup::StopAutoReplace(GroupID group_id, EngineID engine_id) +{ + EnforcePrecondition(false, IsValidGroup(group_id) || group_id == ALL_GROUP); + + return AIObject::DoCommand(0, 3 | (group_id << 16), (::INVALID_ENGINE << 16) | engine_id, CMD_SET_AUTOREPLACE); +} diff --git a/src/ai/api/ai_group.hpp b/src/ai/api/ai_group.hpp new file mode 100644 index 000000000..84569c562 --- /dev/null +++ b/src/ai/api/ai_group.hpp @@ -0,0 +1,170 @@ +/* $Id$ */ + +/** @file ai_group.hpp Everything to put vehicles into groups. */ + +#ifndef AI_GROUP_HPP +#define AI_GROUP_HPP + +#include "ai_object.hpp" +#include "ai_vehicle.hpp" + +/** + * Class that handles all group related functions. + */ +class AIGroup : public AIObject { +public: + static const char *GetClassName() { return "AIGroup"; } + + /** + * The group IDs of some special groups. + */ + enum GroupID { + /* Values are important, as they represent the internal state of the game (see group_type.h). */ + ALL_GROUP = 0xFFFD, //!< All vehicles are in this group. + DEFAULT_GROUP = 0xFFFE, //!< Vehicles not put in any other group are in this one. + INVALID_GROUP = 0xFFFF, //!< An invalid group id. + }; + + /** + * Checks whether the given group is valid. + * @param group_id The group to check. + * @pre group_id != DEFAULT_GROUP && group_id != ALL_GROUP. + * @return True if and only if the group is valid. + */ + static bool IsValidGroup(GroupID group_id); + + /** + * Create a new group. + * @param vehicle_type The type of vehicle to create a group for. + * @return The GroupID of the new group, or an invalid GroupID when + * it failed. Check the return value using IsValidGroup(). In test-mode + * 0 is returned if it was successful; any other value indicates failure. + */ + static GroupID CreateGroup(AIVehicle::VehicleType vehicle_type); + + /** + * Delete the given group. When the deletion succeeds all vehicles in the + * given group will move to the DEFAULT_GROUP. + * @param group_id The group to delete. + * @pre IsValidGroup(group_id). + * @return True if and only if the group was succesfully deleted. + */ + static bool DeleteGroup(GroupID group_id); + + /** + * Get the vehicle type of a group. + * @param group_id The group to get the type from. + * @pre IsValidGroup(group_id). + * @return The vehicletype of the given group. + */ + static AIVehicle::VehicleType GetVehicleType(GroupID group_id); + + /** + * Set the name of a group. + * @param group_id The group to set the name for. + * @param name The name for the group. + * @pre IsValidGroup(group_id). + * @pre 'name' must have at least one character. + * @pre 'name' must have at most 30 characters. + * @exception AIError::ERR_NAME_IS_NOT_UNIQUE + * @return True if and only if the name was changed. + */ + static bool SetName(GroupID group_id, const char *name); + + /** + * Get the name of a group. + * @param group_id The group to get the name of. + * @pre IsValidGroup(group_id). + * @return The name the group has. + */ + static const char *GetName(GroupID group_id); + + /** + * Enable or disable autoreplace protected. If the protection is + * enabled, global autoreplace won't affect vehicles in this group. + * @param group_id The group to change the protection for. + * @param enable True if protection should be enabled. + * @pre IsValidGroup(group_id). + * @return True if and only if the protection was succesfully changed. + */ + static bool EnableAutoReplaceProtection(GroupID group_id, bool enable); + + /** + * Get the autoreplace protection status. + * @param group_id The group to get the protection status for. + * @pre IsValidGroup(group_id). + * @return The autoreplace protection status for the given group. + */ + static bool GetAutoReplaceProtection(GroupID group_id); + + /** + * Get the number of engines in a given group. + * @param group_id The group to get the number of engines in. + * @param engine_id The engine id to count. + * @pre IsValidGroup(group_id) || group_id == ALL_GROUP || group_id == DEFAULT_GROUP. + * @return The number of engines with id engine_id in the group with id group_id. + */ + static int32 GetNumEngines(GroupID group_id, EngineID engine_id); + + /** + * Move a vehicle to a group. + * @param group_id The group to move the vehicel to. + * @param vehicle_id The vehicle to move to the group. + * @pre IsValidGroup(group_id) || group_id == DEFAULT_GROUP. + * @pre AIVehicle::IsValidVehicle(vehicle_id). + * @return True if and only if the vehicle was succesfully moved to the group. + * @note A vehicle can be in only one group at the same time. To remove it from + * a group, move it to another or to DEFAULT_GROUP. Moving the vehicle to the + * given group means removing it from another group. + */ + static bool MoveVehicle(GroupID group_id, VehicleID vehicle_id); + + /** + * Enable or disable the removal of wagons when a (part of a) vehicle is + * (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. + * @param keep_length If true, wagons will be removed if the a new engine is longer. + * @return True if and only if the value was succesfully changed. + */ + static bool EnableWagonRemoval(bool keep_length); + + /** + * Get the current status of wagon removal. + * @return Whether or not wagon removal is enabled. + */ + static bool HasWagonRemoval(); + + /** + * Start replacing all vehicles with a specified engine with another engine. + * @param group_id The group to replace vehicles from. Use ALL_GROUP to replace + * vehicles from all groups that haven't set autoreplace protection. + * @param engine_id_old The engine id to start replacing. + * @param engine_id_new The engine id to replace with. + * @pre IsValidGroup(group_id) || group_id == ALL_GROUP. + * @pre AIEngine.IsValidEngine(engine_id_new). + * @note To stop autoreplacing engine_id_old, call StopAutoReplace(group_id, engine_id_old). + */ + static bool SetAutoReplace(GroupID group_id, EngineID engine_id_old, EngineID engine_id_new); + + /** + * Get the EngineID the given EngineID is replaced with. + * @param group_id The group to get the replacement from. + * @param engine_id The engine that is being replaced. + * @pre IsValidGroup(group_id) || group_id == ALL_GROUP. + * @return The EngineID that is replacing engine_id or an invalid EngineID + * in case engine_id is not begin replaced. + */ + static EngineID GetEngineReplacement(GroupID group_id, EngineID engine_id); + + /** + * Stop replacing a certain engine in the specified group. + * @param group_id The group to stop replacing the engine in. + * @param engine_id The engine id to stop replacing with another engine. + * @pre IsValidGroup(group_id) || group_id == ALL_GROUP. + * @return True if and if the replacing was succesfully stopped. + */ + static bool StopAutoReplace(GroupID group_id, EngineID engine_id); +}; + +#endif /* AI_GROUP_HPP */ diff --git a/src/ai/api/ai_group.hpp.sq b/src/ai/api/ai_group.hpp.sq new file mode 100644 index 000000000..3556f5cc9 --- /dev/null +++ b/src/ai/api/ai_group.hpp.sq @@ -0,0 +1,46 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_group.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIGroup::GroupID GetParam(ForceType<AIGroup::GroupID>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIGroup::GroupID)tmp; } + template <> int Return<AIGroup::GroupID>(HSQUIRRELVM vm, AIGroup::GroupID res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIGroup to be used as Squirrel parameter */ + template <> AIGroup *GetParam(ForceType<AIGroup *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIGroup *)instance; } + template <> AIGroup &GetParam(ForceType<AIGroup &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIGroup *)instance; } + template <> const AIGroup *GetParam(ForceType<const AIGroup *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIGroup *)instance; } + template <> const AIGroup &GetParam(ForceType<const AIGroup &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIGroup *)instance; } + template <> int Return<AIGroup *>(HSQUIRRELVM vm, AIGroup *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIGroup", res, NULL, DefSQDestructorCallback<AIGroup>); return 1; } +}; // namespace SQConvert + +void SQAIGroup_Register(Squirrel *engine) { + DefSQClass <AIGroup> SQAIGroup("AIGroup"); + SQAIGroup.PreRegister(engine); + SQAIGroup.AddConstructor<void (AIGroup::*)(), 1>(engine, "x"); + + SQAIGroup.DefSQConst(engine, AIGroup::ALL_GROUP, "ALL_GROUP"); + SQAIGroup.DefSQConst(engine, AIGroup::DEFAULT_GROUP, "DEFAULT_GROUP"); + SQAIGroup.DefSQConst(engine, AIGroup::INVALID_GROUP, "INVALID_GROUP"); + + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::GetClassName, "GetClassName", 1, "x"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::IsValidGroup, "IsValidGroup", 2, "xi"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::CreateGroup, "CreateGroup", 2, "xi"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::DeleteGroup, "DeleteGroup", 2, "xi"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::GetVehicleType, "GetVehicleType", 2, "xi"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::SetName, "SetName", 3, "xis"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::GetName, "GetName", 2, "xi"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::EnableAutoReplaceProtection, "EnableAutoReplaceProtection", 3, "xib"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::GetAutoReplaceProtection, "GetAutoReplaceProtection", 2, "xi"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::GetNumEngines, "GetNumEngines", 3, "xii"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::MoveVehicle, "MoveVehicle", 3, "xii"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::EnableWagonRemoval, "EnableWagonRemoval", 2, "xb"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::HasWagonRemoval, "HasWagonRemoval", 1, "x"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::SetAutoReplace, "SetAutoReplace", 4, "xiii"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::GetEngineReplacement, "GetEngineReplacement", 3, "xii"); + SQAIGroup.DefSQStaticMethod(engine, &AIGroup::StopAutoReplace, "StopAutoReplace", 3, "xii"); + + SQAIGroup.PostRegister(engine); +} diff --git a/src/ai/api/ai_grouplist.cpp b/src/ai/api/ai_grouplist.cpp new file mode 100644 index 000000000..be57b3750 --- /dev/null +++ b/src/ai/api/ai_grouplist.cpp @@ -0,0 +1,16 @@ +/* $Id$ */ + +/** @file ai_grouplist.cpp Implementation of AIGroupList and friends. */ + +#include "ai_grouplist.hpp" +#include "../../openttd.h" +#include "../../company_func.h" +#include "../../group.h" + +AIGroupList::AIGroupList() +{ + Group *g; + FOR_ALL_GROUPS(g) { + if (g->owner == _current_company) this->AddItem(g->index); + } +} diff --git a/src/ai/api/ai_grouplist.hpp b/src/ai/api/ai_grouplist.hpp new file mode 100644 index 000000000..d97ef85c7 --- /dev/null +++ b/src/ai/api/ai_grouplist.hpp @@ -0,0 +1,21 @@ +/* $Id$ */ + +/** @file ai_grouplist.hpp List all the groups (you own). */ + +#ifndef AI_GROUPLIST_HPP +#define AI_GROUPLIST_HPP + +#include "ai_abstractlist.hpp" + +/** + * Creates a list of groups of which you are the owner. + * @note Neither AIGroup.ALL_GROUP nor AIGroup.DEFAULT_GROUP is in this list. + * @ingroup AIList + */ +class AIGroupList : public AIAbstractList { +public: + static const char *GetClassName() { return "AIGroupList"; } + AIGroupList(); +}; + +#endif /* AI_GROUPLIST_HPP */ diff --git a/src/ai/api/ai_grouplist.hpp.sq b/src/ai/api/ai_grouplist.hpp.sq new file mode 100644 index 000000000..b5c4d945d --- /dev/null +++ b/src/ai/api/ai_grouplist.hpp.sq @@ -0,0 +1,23 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_grouplist.hpp" + +namespace SQConvert { + /* Allow AIGroupList to be used as Squirrel parameter */ + template <> AIGroupList *GetParam(ForceType<AIGroupList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIGroupList *)instance; } + template <> AIGroupList &GetParam(ForceType<AIGroupList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIGroupList *)instance; } + template <> const AIGroupList *GetParam(ForceType<const AIGroupList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIGroupList *)instance; } + template <> const AIGroupList &GetParam(ForceType<const AIGroupList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIGroupList *)instance; } + template <> int Return<AIGroupList *>(HSQUIRRELVM vm, AIGroupList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIGroupList", res, NULL, DefSQDestructorCallback<AIGroupList>); return 1; } +}; // namespace SQConvert + +void SQAIGroupList_Register(Squirrel *engine) { + DefSQClass <AIGroupList> SQAIGroupList("AIGroupList"); + SQAIGroupList.PreRegister(engine, "AIAbstractList"); + SQAIGroupList.AddConstructor<void (AIGroupList::*)(), 1>(engine, "x"); + + SQAIGroupList.DefSQStaticMethod(engine, &AIGroupList::GetClassName, "GetClassName", 1, "x"); + + SQAIGroupList.PostRegister(engine); +} diff --git a/src/ai/api/ai_industry.cpp b/src/ai/api/ai_industry.cpp new file mode 100644 index 000000000..64687af51 --- /dev/null +++ b/src/ai/api/ai_industry.cpp @@ -0,0 +1,170 @@ +/* $Id$ */ + +/** @file ai_industry.cpp Implementation of AIIndustry. */ + +#include "ai_industry.hpp" +#include "ai_cargo.hpp" +#include "ai_map.hpp" +#include "../../openttd.h" +#include "../../tile_type.h" +#include "../../industry.h" +#include "../../strings_func.h" +#include "../../station_func.h" +#include "table/strings.h" + +/* static */ IndustryID AIIndustry::GetMaxIndustryID() +{ + return ::GetMaxIndustryIndex(); +} + +/* static */ int32 AIIndustry::GetIndustryCount() +{ + return ::GetNumIndustries(); +} + +/* static */ bool AIIndustry::IsValidIndustry(IndustryID industry_id) +{ + return ::IsValidIndustryID(industry_id); +} + +/* static */ const char *AIIndustry::GetName(IndustryID industry_id) +{ + if (!IsValidIndustry(industry_id)) return NULL; + static const int len = 64; + char *industry_name = MallocT<char>(len); + + ::SetDParam(0, industry_id); + ::GetString(industry_name, STR_INDUSTRY, &industry_name[len - 1]); + + return industry_name; +} + +/* static */ int32 AIIndustry::GetProduction(IndustryID industry_id, CargoID cargo_id) +{ + if (!IsValidIndustry(industry_id)) return -1; + if (!AICargo::IsValidCargo(cargo_id)) return -1; + + const Industry *i = ::GetIndustry(industry_id); + const IndustrySpec *indsp = ::GetIndustrySpec(i->type); + + for (byte j = 0; j < lengthof(indsp->produced_cargo); j++) + if (indsp->produced_cargo[j] == cargo_id) return i->production_rate[j] * 8; + + return -1; +} + +/* static */ bool AIIndustry::IsCargoAccepted(IndustryID industry_id, CargoID cargo_id) +{ + if (!IsValidIndustry(industry_id)) return false; + if (!AICargo::IsValidCargo(cargo_id)) return false; + + const Industry *i = ::GetIndustry(industry_id); + const IndustrySpec *indsp = ::GetIndustrySpec(i->type); + + for (byte j = 0; j < lengthof(indsp->accepts_cargo); j++) + if (indsp->accepts_cargo[j] == cargo_id) return true; + + return false; +} + +/* static */ int32 AIIndustry::GetStockpiledCargo(IndustryID industry_id, CargoID cargo_id) +{ + if (!IsValidIndustry(industry_id)) return -1; + if (!AICargo::IsValidCargo(cargo_id)) return -1; + + Industry *ind = ::GetIndustry(industry_id); + for (uint i = 0; i < lengthof(ind->accepts_cargo); i++) { + CargoID cid = ind->accepts_cargo[i]; + if (cid == cargo_id) { + return ind->incoming_cargo_waiting[i]; + } + } + + return -1; +} + +/* static */ int32 AIIndustry::GetLastMonthProduction(IndustryID industry_id, CargoID cargo_id) +{ + if (!IsValidIndustry(industry_id)) return -1; + if (!AICargo::IsValidCargo(cargo_id)) return -1; + + const Industry *i = ::GetIndustry(industry_id); + const IndustrySpec *indsp = ::GetIndustrySpec(i->type); + + for (byte j = 0; j < lengthof(indsp->produced_cargo); j++) + if (indsp->produced_cargo[j] == cargo_id) return i->last_month_production[j]; + + return -1; +} + +/* static */ int32 AIIndustry::GetLastMonthTransported(IndustryID industry_id, CargoID cargo_id) +{ + if (!IsValidIndustry(industry_id)) return -1; + if (!AICargo::IsValidCargo(cargo_id)) return -1; + + const Industry *i = ::GetIndustry(industry_id); + const IndustrySpec *indsp = ::GetIndustrySpec(i->type); + + for (byte j = 0; j < lengthof(indsp->produced_cargo); j++) + if (indsp->produced_cargo[j] == cargo_id) return i->last_month_transported[j]; + + return -1; +} + +/* static */ TileIndex AIIndustry::GetLocation(IndustryID industry_id) +{ + if (!IsValidIndustry(industry_id)) return INVALID_TILE; + + return ::GetIndustry(industry_id)->xy; +} + +/* static */ int32 AIIndustry::GetAmountOfStationsAround(IndustryID industry_id) +{ + if (!IsValidIndustry(industry_id)) return -1; + + Industry *ind = ::GetIndustry(industry_id); + return (int32)::FindStationsAroundTiles(ind->xy, ind->width, ind->height).size(); +} + +/* static */ int32 AIIndustry::GetDistanceManhattanToTile(IndustryID industry_id, TileIndex tile) +{ + if (!IsValidIndustry(industry_id)) return -1; + + return AIMap::DistanceManhattan(tile, GetLocation(industry_id)); +} + +/* static */ int32 AIIndustry::GetDistanceSquareToTile(IndustryID industry_id, TileIndex tile) +{ + if (!IsValidIndustry(industry_id)) return -1; + + return AIMap::DistanceSquare(tile, GetLocation(industry_id)); +} + +/* static */ bool AIIndustry::IsBuiltOnWater(IndustryID industry_id) +{ + if (!IsValidIndustry(industry_id)) return false; + + return (::GetIndustrySpec(::GetIndustry(industry_id)->type)->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0; +} + +/* static */ bool AIIndustry::HasHeliportAndDock(IndustryID industry_id) +{ + if (!IsValidIndustry(industry_id)) return false; + + return (::GetIndustrySpec(::GetIndustry(industry_id)->type)->behaviour & INDUSTRYBEH_AI_AIRSHIP_ROUTES) != 0; +} + +/* static */ TileIndex AIIndustry::GetHeliportAndDockLocation(IndustryID industry_id) +{ + if (!IsValidIndustry(industry_id)) return INVALID_TILE; + if (!HasHeliportAndDock(industry_id)) return INVALID_TILE; + + return ::GetIndustry(industry_id)->xy; +} + +/* static */ IndustryType AIIndustry::GetIndustryType(IndustryID industry_id) +{ + if (!IsValidIndustry(industry_id)) return INVALID_INDUSTRYTYPE; + + return ::GetIndustry(industry_id)->type; +} diff --git a/src/ai/api/ai_industry.hpp b/src/ai/api/ai_industry.hpp new file mode 100644 index 000000000..1b3365a97 --- /dev/null +++ b/src/ai/api/ai_industry.hpp @@ -0,0 +1,171 @@ +/* $Id$ */ + +/** @file ai_industry.hpp Everything to query and build industries. */ + +#ifndef AI_INDUSTRY_HPP +#define AI_INDUSTRY_HPP + +#include "ai_object.hpp" + +/** + * Class that handles all industry related functions. + */ +class AIIndustry : public AIObject { +public: + static const char *GetClassName() { return "AIIndustry"; } + + /** + * Gets the maximum industry index; there are no valid industries with a + * higher index. + * @return The maximum industry index. + * @post Return value is always non-negative. + */ + static IndustryID GetMaxIndustryID(); + + /** + * Gets the number of industries. This is different than GetMaxIndustryID() + * because of the way OpenTTD works internally. + * @return The number of industries. + * @post Return value is always non-negative. + */ + static int32 GetIndustryCount(); + + /** + * Checks whether the given industry index is valid. + * @param industry_id The index to check. + * @return True if and only if the industry is valid. + */ + static bool IsValidIndustry(IndustryID industry_id); + + /** + * Get the name of the industry. + * @param industry_id The industry to get the name of. + * @pre IsValidIndustry(industry_id). + * @return The name of the industry. + */ + static const char *GetName(IndustryID industry_id); + + /** + * Gets the production of a cargo of the industry. + * @param industry_id The index of the industry. + * @param cargo_id The index of the cargo. + * @pre IsValidIndustry(industry_id). + * @pre AICargo::IsValidCargo(cargo_id). + * @return The production of the cargo for this industry, or -1 if + * this industry doesn't produce this cargo. + */ + static int32 GetProduction(IndustryID industry_id, CargoID cargo_id); + + /** + * See if an industry accepts a certain cargo. + * @param industry_id The index of the industry. + * @param cargo_id The index of the cargo. + * @pre IsValidIndustry(industry_id). + * @pre AICargo::IsValidCargo(cargo_id). + * @return The production of the cargo for this industry. + */ + static bool IsCargoAccepted(IndustryID industry_id, CargoID cargo_id); + + /** + * Get the amount of cargo stockpiled for processing. + * @param industry_id The index of the industry. + * @param cargo_id The index of the cargo. + * @pre IsValidIndustry(industry_id). + * @pre AICargo::IsValidCargo(cargo_id). + * @return The amount of cargo that is waiting for processing. + */ + static int32 GetStockpiledCargo(IndustryID industry_id, CargoID cargo_id); + + /** + * Get the total last month's production of the given cargo at an industry. + * @param industry_id The index of the industry. + * @param cargo_id The index of the cargo. + * @pre IsValidIndustry(industry_id). + * @pre AICargo::IsValidCargo(cargo_id). + * @return The last month's production of the given cargo for this industry. + */ + static int32 GetLastMonthProduction(IndustryID industry_id, CargoID cargo_id); + + /** + * Get the total amount of cargo transported from an industry last month. + * @param industry_id The index of the industry. + * @param cargo_id The index of the cargo. + * @pre IsValidIndustry(industry_id). + * @pre AICargo::IsValidCargo(cargo_id). + * @return The amount of given cargo transported from this industry last month. + */ + static int32 GetLastMonthTransported(IndustryID industry_id, CargoID cargo_id); + + /** + * Gets the location of the industry. + * @param industry_id The index of the industry. + * @pre IsValidIndustry(industry_id). + * @return The location of the industry. + */ + static TileIndex GetLocation(IndustryID industry_id); + + /** + * Get the number of stations around an industry. + * @param industry_id The index of the industry. + * @pre IsValidIndustry(industry_id). + * @return The number of stations around an industry. + */ + static int32 GetAmountOfStationsAround(IndustryID industry_id); + + /** + * Get the manhattan distance from the tile to the AIIndustry::GetLocation() + * of the industry. + * @param industry_id The industry to get the distance to. + * @param tile The tile to get the distance to. + * @pre IsValidIndustry(industry_id). + * @pre AIMap::IsValidTile(tile). + * @return The distance between industry and tile. + */ + static int32 GetDistanceManhattanToTile(IndustryID industry_id, TileIndex tile); + + /** + * Get the square distance from the tile to the AIIndustry::GetLocation() + * of the industry. + * @param industry_id The industry to get the distance to. + * @param tile The tile to get the distance to. + * @pre IsValidIndustry(industry_id). + * @pre AIMap::IsValidTile(tile). + * @return The distance between industry and tile. + */ + static int32 GetDistanceSquareToTile(IndustryID industry_id, TileIndex tile); + + /** + * Is this industry built on water. + * @param industry_id The index of the industry. + * @pre IsValidIndustry(industry_id). + * @return True when the industry is built on water. + */ + static bool IsBuiltOnWater(IndustryID industry_id); + + /** + * Does this industry have a heliport and dock? + * @param industry_id The index of the industry. + * @pre IsValidIndustry(industry_id). + * @return True when the industry has a heliport and dock. + */ + static bool HasHeliportAndDock(IndustryID industry_id); + + /** + * Gets the location of the industry's heliport/dock. + * @param industry_id The index of the industry. + * @pre IsValidIndustry(industry_id). + * @pre HasHeliportAndDock(industry_id). + * @return The location of the industry's heliport/dock. + */ + static TileIndex GetHeliportAndDockLocation(IndustryID industry_id); + + /** + * Get the IndustryType of the industry. + * @param industry_id The index of the industry. + * @pre IsValidIndustry(industry_id). + * @return The IndustryType of the industry. + */ + static IndustryType GetIndustryType(IndustryID industry_id); +}; + +#endif /* AI_INDUSTRY_HPP */ diff --git a/src/ai/api/ai_industry.hpp.sq b/src/ai/api/ai_industry.hpp.sq new file mode 100644 index 000000000..dc0493efb --- /dev/null +++ b/src/ai/api/ai_industry.hpp.sq @@ -0,0 +1,40 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_industry.hpp" + +namespace SQConvert { + /* Allow AIIndustry to be used as Squirrel parameter */ + template <> AIIndustry *GetParam(ForceType<AIIndustry *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustry *)instance; } + template <> AIIndustry &GetParam(ForceType<AIIndustry &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustry *)instance; } + template <> const AIIndustry *GetParam(ForceType<const AIIndustry *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustry *)instance; } + template <> const AIIndustry &GetParam(ForceType<const AIIndustry &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustry *)instance; } + template <> int Return<AIIndustry *>(HSQUIRRELVM vm, AIIndustry *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustry", res, NULL, DefSQDestructorCallback<AIIndustry>); return 1; } +}; // namespace SQConvert + +void SQAIIndustry_Register(Squirrel *engine) { + DefSQClass <AIIndustry> SQAIIndustry("AIIndustry"); + SQAIIndustry.PreRegister(engine); + SQAIIndustry.AddConstructor<void (AIIndustry::*)(), 1>(engine, "x"); + + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetClassName, "GetClassName", 1, "x"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetMaxIndustryID, "GetMaxIndustryID", 1, "x"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetIndustryCount, "GetIndustryCount", 1, "x"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::IsValidIndustry, "IsValidIndustry", 2, "xi"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetName, "GetName", 2, "xi"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetProduction, "GetProduction", 3, "xii"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::IsCargoAccepted, "IsCargoAccepted", 3, "xii"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetStockpiledCargo, "GetStockpiledCargo", 3, "xii"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetLastMonthProduction, "GetLastMonthProduction", 3, "xii"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetLastMonthTransported, "GetLastMonthTransported", 3, "xii"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetLocation, "GetLocation", 2, "xi"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetAmountOfStationsAround, "GetAmountOfStationsAround", 2, "xi"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetDistanceManhattanToTile, "GetDistanceManhattanToTile", 3, "xii"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetDistanceSquareToTile, "GetDistanceSquareToTile", 3, "xii"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::IsBuiltOnWater, "IsBuiltOnWater", 2, "xi"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::HasHeliportAndDock, "HasHeliportAndDock", 2, "xi"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetHeliportAndDockLocation, "GetHeliportAndDockLocation", 2, "xi"); + SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetIndustryType, "GetIndustryType", 2, "xi"); + + SQAIIndustry.PostRegister(engine); +} diff --git a/src/ai/api/ai_industrylist.cpp b/src/ai/api/ai_industrylist.cpp new file mode 100644 index 000000000..be8fbcfa4 --- /dev/null +++ b/src/ai/api/ai_industrylist.cpp @@ -0,0 +1,42 @@ +/* $Id$ */ + +/** @file ai_industrylist.cpp Implementation of AIIndustryList and friends. */ + +#include "ai_industrylist.hpp" +#include "../../openttd.h" +#include "../../tile_type.h" +#include "../../industry.h" + +AIIndustryList::AIIndustryList() +{ + Industry *i; + FOR_ALL_INDUSTRIES(i) { + this->AddItem(i->index); + } +} + +AIIndustryList_CargoAccepting::AIIndustryList_CargoAccepting(CargoID cargo_id) +{ + const Industry *i; + const IndustrySpec *indsp; + + FOR_ALL_INDUSTRIES(i) { + indsp = ::GetIndustrySpec(i->type); + + for (byte j = 0; j < lengthof(indsp->accepts_cargo); j++) + if (indsp->accepts_cargo[j] == cargo_id) this->AddItem(i->index); + } +} + +AIIndustryList_CargoProducing::AIIndustryList_CargoProducing(CargoID cargo_id) +{ + const Industry *i; + const IndustrySpec *indsp; + + FOR_ALL_INDUSTRIES(i) { + indsp = ::GetIndustrySpec(i->type); + + for (byte j = 0; j < lengthof(indsp->produced_cargo); j++) + if (indsp->produced_cargo[j] == cargo_id) this->AddItem(i->index); + } +} diff --git a/src/ai/api/ai_industrylist.hpp b/src/ai/api/ai_industrylist.hpp new file mode 100644 index 000000000..2afca7b97 --- /dev/null +++ b/src/ai/api/ai_industrylist.hpp @@ -0,0 +1,49 @@ +/* $Id$ */ + +/** @file ai_industrylist.hpp List all the industries. */ + +#ifndef AI_INDUSTRYLIST_HPP +#define AI_INDUSTRYLIST_HPP + +#include "ai_abstractlist.hpp" + +/** + * Creates a list of industries that are currently on the map. + * @ingroup AIList + */ +class AIIndustryList : public AIAbstractList { +public: + static const char *GetClassName() { return "AIIndustryList"; } + AIIndustryList(); +}; + +/** + * Creates a list of industries that accepts a given cargo. + * @ingroup AIList + */ +class AIIndustryList_CargoAccepting : public AIAbstractList { +public: + static const char *GetClassName() { return "AIIndustryList_CargoAccepting"; } + + /** + * @param cargo_id The cargo this industry should accept. + */ + AIIndustryList_CargoAccepting(CargoID cargo_id); +}; + +/** + * Creates a list of industries that can produce a given cargo. + * @note It also contains industries that currently produces 0 units of the cargo. + * @ingroup AIList + */ +class AIIndustryList_CargoProducing : public AIAbstractList { +public: + static const char *GetClassName() { return "AIIndustryList_CargoProducing"; } + + /** + * @param cargo_id The cargo this industry should produce. + */ + AIIndustryList_CargoProducing(CargoID cargo_id); +}; + +#endif /* AI_INDUSTRYLIST_HPP */ diff --git a/src/ai/api/ai_industrylist.hpp.sq b/src/ai/api/ai_industrylist.hpp.sq new file mode 100644 index 000000000..1abc9c549 --- /dev/null +++ b/src/ai/api/ai_industrylist.hpp.sq @@ -0,0 +1,61 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_industrylist.hpp" + +namespace SQConvert { + /* Allow AIIndustryList to be used as Squirrel parameter */ + template <> AIIndustryList *GetParam(ForceType<AIIndustryList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustryList *)instance; } + template <> AIIndustryList &GetParam(ForceType<AIIndustryList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryList *)instance; } + template <> const AIIndustryList *GetParam(ForceType<const AIIndustryList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustryList *)instance; } + template <> const AIIndustryList &GetParam(ForceType<const AIIndustryList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryList *)instance; } + template <> int Return<AIIndustryList *>(HSQUIRRELVM vm, AIIndustryList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryList", res, NULL, DefSQDestructorCallback<AIIndustryList>); return 1; } +}; // namespace SQConvert + +void SQAIIndustryList_Register(Squirrel *engine) { + DefSQClass <AIIndustryList> SQAIIndustryList("AIIndustryList"); + SQAIIndustryList.PreRegister(engine, "AIAbstractList"); + SQAIIndustryList.AddConstructor<void (AIIndustryList::*)(), 1>(engine, "x"); + + SQAIIndustryList.DefSQStaticMethod(engine, &AIIndustryList::GetClassName, "GetClassName", 1, "x"); + + SQAIIndustryList.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIIndustryList_CargoAccepting to be used as Squirrel parameter */ + template <> AIIndustryList_CargoAccepting *GetParam(ForceType<AIIndustryList_CargoAccepting *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustryList_CargoAccepting *)instance; } + template <> AIIndustryList_CargoAccepting &GetParam(ForceType<AIIndustryList_CargoAccepting &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryList_CargoAccepting *)instance; } + template <> const AIIndustryList_CargoAccepting *GetParam(ForceType<const AIIndustryList_CargoAccepting *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustryList_CargoAccepting *)instance; } + template <> const AIIndustryList_CargoAccepting &GetParam(ForceType<const AIIndustryList_CargoAccepting &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryList_CargoAccepting *)instance; } + template <> int Return<AIIndustryList_CargoAccepting *>(HSQUIRRELVM vm, AIIndustryList_CargoAccepting *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryList_CargoAccepting", res, NULL, DefSQDestructorCallback<AIIndustryList_CargoAccepting>); return 1; } +}; // namespace SQConvert + +void SQAIIndustryList_CargoAccepting_Register(Squirrel *engine) { + DefSQClass <AIIndustryList_CargoAccepting> SQAIIndustryList_CargoAccepting("AIIndustryList_CargoAccepting"); + SQAIIndustryList_CargoAccepting.PreRegister(engine, "AIAbstractList"); + SQAIIndustryList_CargoAccepting.AddConstructor<void (AIIndustryList_CargoAccepting::*)(CargoID cargo_id), 2>(engine, "xi"); + + SQAIIndustryList_CargoAccepting.DefSQStaticMethod(engine, &AIIndustryList_CargoAccepting::GetClassName, "GetClassName", 1, "x"); + + SQAIIndustryList_CargoAccepting.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIIndustryList_CargoProducing to be used as Squirrel parameter */ + template <> AIIndustryList_CargoProducing *GetParam(ForceType<AIIndustryList_CargoProducing *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustryList_CargoProducing *)instance; } + template <> AIIndustryList_CargoProducing &GetParam(ForceType<AIIndustryList_CargoProducing &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryList_CargoProducing *)instance; } + template <> const AIIndustryList_CargoProducing *GetParam(ForceType<const AIIndustryList_CargoProducing *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustryList_CargoProducing *)instance; } + template <> const AIIndustryList_CargoProducing &GetParam(ForceType<const AIIndustryList_CargoProducing &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryList_CargoProducing *)instance; } + template <> int Return<AIIndustryList_CargoProducing *>(HSQUIRRELVM vm, AIIndustryList_CargoProducing *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryList_CargoProducing", res, NULL, DefSQDestructorCallback<AIIndustryList_CargoProducing>); return 1; } +}; // namespace SQConvert + +void SQAIIndustryList_CargoProducing_Register(Squirrel *engine) { + DefSQClass <AIIndustryList_CargoProducing> SQAIIndustryList_CargoProducing("AIIndustryList_CargoProducing"); + SQAIIndustryList_CargoProducing.PreRegister(engine, "AIAbstractList"); + SQAIIndustryList_CargoProducing.AddConstructor<void (AIIndustryList_CargoProducing::*)(CargoID cargo_id), 2>(engine, "xi"); + + SQAIIndustryList_CargoProducing.DefSQStaticMethod(engine, &AIIndustryList_CargoProducing::GetClassName, "GetClassName", 1, "x"); + + SQAIIndustryList_CargoProducing.PostRegister(engine); +} diff --git a/src/ai/api/ai_industrytype.cpp b/src/ai/api/ai_industrytype.cpp new file mode 100644 index 000000000..34d69f5f8 --- /dev/null +++ b/src/ai/api/ai_industrytype.cpp @@ -0,0 +1,115 @@ +/* $Id$ */ + +/** @file ai_industrytype.cpp Implementation of AIIndustryType. */ + +#include "ai_industrytype.hpp" +#include "ai_map.hpp" +#include "../../openttd.h" +#include "../../command_type.h" +#include "../../settings_type.h" +#include "../../strings_func.h" +#include "../../tile_type.h" +#include "../../industry.h" + +/* static */ bool AIIndustryType::IsValidIndustryType(IndustryType industry_type) +{ + if (industry_type >= NUM_INDUSTRYTYPES) return false; + + return ::GetIndustrySpec(industry_type)->enabled; +} + +/* static */ bool AIIndustryType::IsRawIndustry(IndustryType industry_type) +{ + if (!IsValidIndustryType(industry_type)) return false; + + return ::GetIndustrySpec(industry_type)->IsRawIndustry(); +} + +/* static */ bool AIIndustryType::ProductionCanIncrease(IndustryType industry_type) +{ + if (!IsValidIndustryType(industry_type)) return false; + + if (_settings_game.game_creation.landscape != LT_TEMPERATE) return true; + return (::GetIndustrySpec(industry_type)->behaviour & INDUSTRYBEH_DONT_INCR_PROD) == 0; +} + +/* static */ Money AIIndustryType::GetConstructionCost(IndustryType industry_type) +{ + if (!IsValidIndustryType(industry_type)) return false; + + return ::GetIndustrySpec(industry_type)->GetConstructionCost(); +} + +/* static */ const char *AIIndustryType::GetName(IndustryType industry_type) +{ + if (!IsValidIndustryType(industry_type)) return NULL; + static const int len = 64; + char *industrytype_name = MallocT<char>(len); + + ::GetString(industrytype_name, ::GetIndustrySpec(industry_type)->name, &industrytype_name[len - 1]); + + return industrytype_name; +} + +/* static */ AIList *AIIndustryType::GetProducedCargo(IndustryType industry_type) +{ + if (!IsValidIndustryType(industry_type)) return NULL; + + const IndustrySpec *ins = ::GetIndustrySpec(industry_type); + + AIList *list = new AIList(); + for (int i = 0; i < 2; i++) { + if (ins->produced_cargo[i] != CT_INVALID) list->AddItem(ins->produced_cargo[i], 0); + } + + return list; +} + +/* static */ AIList *AIIndustryType::GetAcceptedCargo(IndustryType industry_type) +{ + if (!IsValidIndustryType(industry_type)) return NULL; + + const IndustrySpec *ins = ::GetIndustrySpec(industry_type); + + AIList *list = new AIList(); + for (int i = 0; i < 3; i++) { + if (ins->accepts_cargo[i] != CT_INVALID) list->AddItem(ins->accepts_cargo[i], 0); + } + + return list; +} + +/* static */ bool AIIndustryType::CanBuildIndustry(IndustryType industry_type) +{ + if (!IsValidIndustryType(industry_type)) return false; + if (!::GetIndustrySpec(industry_type)->IsRawIndustry()) return true; + + /* raw_industry_construction == 1 means "Build as other industries" */ + return _settings_game.construction.raw_industry_construction == 1; +} + +/* static */ bool AIIndustryType::CanProspectIndustry(IndustryType industry_type) +{ + if (!IsValidIndustryType(industry_type)) return false; + if (!::GetIndustrySpec(industry_type)->IsRawIndustry()) return false; + + /* raw_industry_construction == 2 means "prospect" */ + return _settings_game.construction.raw_industry_construction == 2; +} + +/* static */ bool AIIndustryType::BuildIndustry(IndustryType industry_type, TileIndex tile) +{ + EnforcePrecondition(false, CanBuildIndustry(industry_type)); + EnforcePrecondition(false, AIMap::IsValidTile(tile)); + + uint32 seed = ::InteractiveRandom(); + return AIObject::DoCommand(tile, (::InteractiveRandomRange(::GetIndustrySpec(industry_type)->num_table) << 16) | industry_type, seed, CMD_BUILD_INDUSTRY); +} + +/* static */ bool AIIndustryType::ProspectIndustry(IndustryType industry_type) +{ + EnforcePrecondition(false, CanProspectIndustry(industry_type)); + + uint32 seed = ::InteractiveRandom(); + return AIObject::DoCommand(0, industry_type, seed, CMD_BUILD_INDUSTRY); +} diff --git a/src/ai/api/ai_industrytype.hpp b/src/ai/api/ai_industrytype.hpp new file mode 100644 index 000000000..88ba6d730 --- /dev/null +++ b/src/ai/api/ai_industrytype.hpp @@ -0,0 +1,114 @@ +/* $Id$ */ + +/** @file ai_industrytype.hpp Everything to query and build industries. */ + +#ifndef AI_INDUSTRYTYPE_HPP +#define AI_INDUSTRYTYPE_HPP + +#include "ai_object.hpp" +#include "ai_error.hpp" +#include "ai_list.hpp" + +/** + * Class that handles all industry-type related functions. + */ +class AIIndustryType : public AIObject { +public: + static const char *GetClassName() { return "AIIndustryType"; } + + /** + * Checks whether the given industry-type is valid. + * @param industry_type The type check. + * @return True if and only if the industry-type is valid. + */ + static bool IsValidIndustryType(IndustryType industry_type); + + /** + * Get the name of an industry-type. + * @param industry_type The type to get the name for. + * @pre IsValidIndustryType(industry_type). + * @return The name of an industry. + */ + static const char *GetName(IndustryType industry_type); + + /** + * Get a list of CargoID possible produced by this industry-type. + * @param industry_type The type to get the CargoIDs for. + * @pre IsValidIndustryType(industry_type). + * @return The CargoIDs of all cargotypes this industry could produce. + */ + static AIList *GetProducedCargo(IndustryType industry_type); + + /** + * Get a list of CargoID accepted by this industry-type. + * @param industry_type The type to get the CargoIDs for. + * @pre IsValidIndustryType(industry_type). + * @return The CargoIDs of all cargotypes this industry accepts. + */ + static AIList *GetAcceptedCargo(IndustryType industry_type); + + /** + * Is this industry type a raw industry? + * @param industry_type The type of the industry. + * @pre IsValidIndustryType(industry_type). + * @return True if it should be handled as a raw industry. + */ + static bool IsRawIndustry(IndustryType industry_type); + + /** + * Can the production of this industry increase? + * @param industry_type The type of the industry. + * @pre IsValidIndustryType(industry_type). + * @return True if the production of this industry can increase. + */ + static bool ProductionCanIncrease(IndustryType industry_type); + + /** + * Get the cost for building this industry-type. + * @param industry_type The type of the industry. + * @pre IsValidIndustryType(industry_type). + * @return The cost for building this industry-type. + */ + static Money GetConstructionCost(IndustryType industry_type); + + /** + * Can you build this type of industry? + * @param industry_type The type of the industry. + * @pre IsValidIndustryType(industry_type). + * @return True if you can prospect this type of industry. + * @note Returns false if you can only prospect this type of industry. + */ + static bool CanBuildIndustry(IndustryType industry_type); + + /** + * Can you prospect this type of industry? + * @param industry_type The type of the industry. + * @pre IsValidIndustryType(industry_type). + * @return True if you can prospect this type of industry. + * @note If the patch setting "Manual primary industry construction method" is set + * to either "None" or "as other industries" this function always returns false. + */ + static bool CanProspectIndustry(IndustryType industry_type); + + /** + * Build an industry of the specified type. + * @param industry_type The type of the industry to build. + * @param tile The tile to build the industry on. + * @pre CanBuildIndustry(industry_type). + * @return True if the industry was succesfully build. + */ + static bool BuildIndustry(IndustryType industry_type, TileIndex tile); + + /** + * Prospect an industry of this type. Prospecting an industries let the game try to create + * an industry on a random place on the map. + * @param industry_type The type of the industry. + * @pre CanProspectIndustry(industry_type). + * @return True if no error occured while trying to prospect. + * @note Even if true is returned there is no guarantee a new industry is build. + * @note If true is returned the money is paid, whether a new industry was build or not. + */ + static bool ProspectIndustry(IndustryType industry_type); +}; + +#endif /* AI_INDUSTRYTYPE_HPP */ diff --git a/src/ai/api/ai_industrytype.hpp.sq b/src/ai/api/ai_industrytype.hpp.sq new file mode 100644 index 000000000..ed5353776 --- /dev/null +++ b/src/ai/api/ai_industrytype.hpp.sq @@ -0,0 +1,34 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_industrytype.hpp" + +namespace SQConvert { + /* Allow AIIndustryType to be used as Squirrel parameter */ + template <> AIIndustryType *GetParam(ForceType<AIIndustryType *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustryType *)instance; } + template <> AIIndustryType &GetParam(ForceType<AIIndustryType &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryType *)instance; } + template <> const AIIndustryType *GetParam(ForceType<const AIIndustryType *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustryType *)instance; } + template <> const AIIndustryType &GetParam(ForceType<const AIIndustryType &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryType *)instance; } + template <> int Return<AIIndustryType *>(HSQUIRRELVM vm, AIIndustryType *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryType", res, NULL, DefSQDestructorCallback<AIIndustryType>); return 1; } +}; // namespace SQConvert + +void SQAIIndustryType_Register(Squirrel *engine) { + DefSQClass <AIIndustryType> SQAIIndustryType("AIIndustryType"); + SQAIIndustryType.PreRegister(engine); + SQAIIndustryType.AddConstructor<void (AIIndustryType::*)(), 1>(engine, "x"); + + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::GetClassName, "GetClassName", 1, "x"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::IsValidIndustryType, "IsValidIndustryType", 2, "xi"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::GetName, "GetName", 2, "xi"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::GetProducedCargo, "GetProducedCargo", 2, "xi"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::GetAcceptedCargo, "GetAcceptedCargo", 2, "xi"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::IsRawIndustry, "IsRawIndustry", 2, "xi"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::ProductionCanIncrease, "ProductionCanIncrease", 2, "xi"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::GetConstructionCost, "GetConstructionCost", 2, "xi"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::CanBuildIndustry, "CanBuildIndustry", 2, "xi"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::CanProspectIndustry, "CanProspectIndustry", 2, "xi"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::BuildIndustry, "BuildIndustry", 3, "xii"); + SQAIIndustryType.DefSQStaticMethod(engine, &AIIndustryType::ProspectIndustry, "ProspectIndustry", 2, "xi"); + + SQAIIndustryType.PostRegister(engine); +} diff --git a/src/ai/api/ai_industrytypelist.cpp b/src/ai/api/ai_industrytypelist.cpp new file mode 100644 index 000000000..b5ef34b50 --- /dev/null +++ b/src/ai/api/ai_industrytypelist.cpp @@ -0,0 +1,15 @@ +/* $Id$ */ + +/** @file ai_industrytypelist.cpp Implementation of AIIndustryTypeList. */ + +#include "ai_industrytypelist.hpp" +#include "../../openttd.h" +#include "../../tile_type.h" +#include "../../industry.h" + +AIIndustryTypeList::AIIndustryTypeList() +{ + for (int i = 0; i < NUM_INDUSTRYTYPES; i++) { + if (AIIndustryType::IsValidIndustryType(i)) this->AddItem(i); + } +} diff --git a/src/ai/api/ai_industrytypelist.hpp b/src/ai/api/ai_industrytypelist.hpp new file mode 100644 index 000000000..55c582c9d --- /dev/null +++ b/src/ai/api/ai_industrytypelist.hpp @@ -0,0 +1,22 @@ +/* $Id$ */ + +/** @file ai_industrytypelist.hpp List all available industry types. */ + +#ifndef AI_INDUSTRYTYPELIST_HPP +#define AI_INDUSTRYTYPELIST_HPP + +#include "ai_abstractlist.hpp" +#include "ai_industrytype.hpp" + +/** + * Creates a list of valid industry types. + * @ingroup AIList + */ +class AIIndustryTypeList : public AIAbstractList { +public: + static const char *GetClassName() { return "AIIndustryTypeList"; } + AIIndustryTypeList(); +}; + + +#endif /* AI_INDUSTRYTYPELIST_HPP */ diff --git a/src/ai/api/ai_industrytypelist.hpp.sq b/src/ai/api/ai_industrytypelist.hpp.sq new file mode 100644 index 000000000..901ee4f68 --- /dev/null +++ b/src/ai/api/ai_industrytypelist.hpp.sq @@ -0,0 +1,23 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_industrytypelist.hpp" + +namespace SQConvert { + /* Allow AIIndustryTypeList to be used as Squirrel parameter */ + template <> AIIndustryTypeList *GetParam(ForceType<AIIndustryTypeList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustryTypeList *)instance; } + template <> AIIndustryTypeList &GetParam(ForceType<AIIndustryTypeList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryTypeList *)instance; } + template <> const AIIndustryTypeList *GetParam(ForceType<const AIIndustryTypeList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustryTypeList *)instance; } + template <> const AIIndustryTypeList &GetParam(ForceType<const AIIndustryTypeList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryTypeList *)instance; } + template <> int Return<AIIndustryTypeList *>(HSQUIRRELVM vm, AIIndustryTypeList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryTypeList", res, NULL, DefSQDestructorCallback<AIIndustryTypeList>); return 1; } +}; // namespace SQConvert + +void SQAIIndustryTypeList_Register(Squirrel *engine) { + DefSQClass <AIIndustryTypeList> SQAIIndustryTypeList("AIIndustryTypeList"); + SQAIIndustryTypeList.PreRegister(engine, "AIAbstractList"); + SQAIIndustryTypeList.AddConstructor<void (AIIndustryTypeList::*)(), 1>(engine, "x"); + + SQAIIndustryTypeList.DefSQStaticMethod(engine, &AIIndustryTypeList::GetClassName, "GetClassName", 1, "x"); + + SQAIIndustryTypeList.PostRegister(engine); +} diff --git a/src/ai/api/ai_list.cpp b/src/ai/api/ai_list.cpp new file mode 100644 index 000000000..57690d341 --- /dev/null +++ b/src/ai/api/ai_list.cpp @@ -0,0 +1,45 @@ +/* $Id$ */ + +/** @file ai_list.cpp Implementation of AIList. */ + +#include <squirrel.h> +#include "ai_list.hpp" + +void AIList::AddItem(int32 item, int32 value) +{ + AIAbstractList::AddItem(item); + this->SetValue(item, value); +} + +void AIList::ChangeItem(int32 item, int32 value) +{ + this->SetValue(item, value); +} + +void AIList::RemoveItem(int32 item) +{ + AIAbstractList::RemoveItem(item); +} + +SQInteger AIList::_set(HSQUIRRELVM vm) { + if (sq_gettype(vm, 2) != OT_INTEGER) return SQ_ERROR; + if (sq_gettype(vm, 3) != OT_INTEGER || sq_gettype(vm, 3) == OT_NULL) { + return sq_throwerror(vm, _SC("you can only assign integers to this list")); + } + + SQInteger idx, val; + sq_getinteger(vm, 2, &idx); + if (sq_gettype(vm, 3) == OT_NULL) { + this->RemoveItem(idx); + return 0; + } + + sq_getinteger(vm, 3, &val); + if (!this->HasItem(idx)) { + this->AddItem(idx, val); + return 0; + } + + this->ChangeItem(idx, val); + return 0; +} diff --git a/src/ai/api/ai_list.hpp b/src/ai/api/ai_list.hpp new file mode 100644 index 000000000..9ce99a8e0 --- /dev/null +++ b/src/ai/api/ai_list.hpp @@ -0,0 +1,47 @@ +/* $Id$ */ + +/** @file ai_list.hpp List custom entries. */ + +#ifndef AI_LIST_HPP +#define AI_LIST_HPP + +#include "ai_abstractlist.hpp" + +/** + * Creates an empty list, in which you can add integers. + * @ingroup AIList + */ +class AIList : public AIAbstractList { +public: + static const char *GetClassName() { return "AIList"; } + +public: + /** + * Add an item to the list. + * @param item the item to add. + * @param value the value to assign. + */ + void AddItem(int32 item, int32 value); + + /** + * Change the value of an item in the list. + * @param item the item to change + * @param value the value to assign. + */ + void ChangeItem(int32 item, int32 value); + + /** + * Remove the item from the list. + * @param item the item to remove. + */ + void RemoveItem(int32 item); + +#ifndef DOXYGEN_SKIP + /** + * Used for [] set from Squirrel. + */ + SQInteger _set(HSQUIRRELVM vm); +#endif /* DOXYGEN_SKIP */ +}; + +#endif /* AI_LIST_HPP */ diff --git a/src/ai/api/ai_list.hpp.sq b/src/ai/api/ai_list.hpp.sq new file mode 100644 index 000000000..dfa270bbf --- /dev/null +++ b/src/ai/api/ai_list.hpp.sq @@ -0,0 +1,28 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_list.hpp" + +namespace SQConvert { + /* Allow AIList to be used as Squirrel parameter */ + template <> AIList *GetParam(ForceType<AIList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIList *)instance; } + template <> AIList &GetParam(ForceType<AIList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIList *)instance; } + template <> const AIList *GetParam(ForceType<const AIList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIList *)instance; } + template <> const AIList &GetParam(ForceType<const AIList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIList *)instance; } + template <> int Return<AIList *>(HSQUIRRELVM vm, AIList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIList", res, NULL, DefSQDestructorCallback<AIList>); return 1; } +}; // namespace SQConvert + +void SQAIList_Register(Squirrel *engine) { + DefSQClass <AIList> SQAIList("AIList"); + SQAIList.PreRegister(engine, "AIAbstractList"); + SQAIList.AddConstructor<void (AIList::*)(), 1>(engine, "x"); + + SQAIList.DefSQStaticMethod(engine, &AIList::GetClassName, "GetClassName", 1, "x"); + + SQAIList.DefSQMethod(engine, &AIList::AddItem, "AddItem", 3, "xii"); + SQAIList.DefSQMethod(engine, &AIList::ChangeItem, "ChangeItem", 3, "xii"); + SQAIList.DefSQMethod(engine, &AIList::RemoveItem, "RemoveItem", 2, "xi"); + SQAIList.DefSQAdvancedMethod(engine, &AIList::_set, "_set"); + + SQAIList.PostRegister(engine); +} diff --git a/src/ai/api/ai_log.cpp b/src/ai/api/ai_log.cpp new file mode 100644 index 000000000..6dc9cb365 --- /dev/null +++ b/src/ai/api/ai_log.cpp @@ -0,0 +1,84 @@ +/* $Id$ */ + +/** @file ai_log.cpp Implementation of AILog. */ + +#include "ai_log.hpp" +#include "../../core/alloc_func.hpp" +#include "../../company_func.h" +#include "../../debug.h" +#include "../../window_func.h" + +/* static */ void AILog::Info(const char *message) +{ + AILog::Log(LOG_INFO, message); +} + +/* static */ void AILog::Warning(const char *message) +{ + AILog::Log(LOG_WARNING, message); +} + +/* static */ void AILog::Error(const char *message) +{ + AILog::Log(LOG_ERROR, message); +} + +/* static */ void AILog::Log(AILog::AILogType level, const char *message) +{ + if (AIObject::GetLogPointer() == NULL) { + AIObject::GetLogPointer() = new LogData(); + LogData *log = (LogData *)AIObject::GetLogPointer(); + + log->lines = CallocT<char *>(80); + log->type = CallocT<AILog::AILogType>(80); + log->count = 80; + log->pos = log->count; + log->used = 0; + } + LogData *log = (LogData *)AIObject::GetLogPointer(); + + /* Go to the next log-line */ + log->pos = (log->pos + 1) % log->count; + + if (log->used != log->count) log->used++; + + /* Free last message, and write new message */ + free(log->lines[log->pos]); + log->lines[log->pos] = strdup(message); + log->type[log->pos] = level; + + /* Cut string after first \n */ + char *p; + while ((p = strchr(log->lines[log->pos], '\n')) != NULL) { + *p = '\0'; + break; + } + + char logc; + + switch (level) { + case LOG_SQ_ERROR: logc = 'S'; break; + case LOG_ERROR: logc = 'E'; break; + case LOG_SQ_INFO: logc = 'P'; break; + case LOG_WARNING: logc = 'W'; break; + case LOG_INFO: logc = 'I'; break; + default: logc = '?'; break; + } + + /* Also still print to debug window */ + DEBUG(ai, level, "[%d] [%c] %s", (uint)_current_company, logc, log->lines[log->pos]); + InvalidateWindowData(WC_AI_DEBUG, 0, _current_company); +} + +/* static */ void AILog::FreeLogPointer() +{ + LogData *log = (LogData *)AIObject::GetLogPointer(); + + for (int i = 0; i < log->count; i++) { + free(log->lines[i]); + } + + free(log->lines); + free(log->type); + delete log; +} diff --git a/src/ai/api/ai_log.hpp b/src/ai/api/ai_log.hpp new file mode 100644 index 000000000..7fd1cdb64 --- /dev/null +++ b/src/ai/api/ai_log.hpp @@ -0,0 +1,76 @@ +/* $Id$ */ + +/** @file ai_log.hpp Everything to handle and issue log messages. */ + +#ifndef AI_LOG_HPP +#define AI_LOG_HPP + +#include "ai_object.hpp" + +/** + * Class that handles all log related functions. + */ +class AILog : public AIObject { + /* AIController needs access to Enum and Log, in order to keep the flow from + * OpenTTD core to NoAI API clear and simple. */ + friend class AIController; + +public: + static const char *GetClassName() { return "AILog"; } + + /** + * Log levels; The value is also feed to DEBUG() lvl. + * This has no use for you, as AI writer. + */ + enum AILogType { + LOG_SQ_ERROR = 0, //!< Squirrel printed an error. + LOG_ERROR = 1, //!< User printed an error. + LOG_SQ_INFO = 2, //!< Squirrel printed some info. + LOG_WARNING = 3, //!< User printed some warning. + LOG_INFO = 4, //!< User printed some info. + }; + + /** + * Internal representation of the log-data inside the AI. + * This has no use for you, as AI writer. + */ + struct LogData { + char **lines; //!< The log-lines. + AILog::AILogType *type; //!< Per line, which type of log it was. + int count; //!< Total amount of log-lines possible. + int pos; //!< Current position in lines. + int used; //!< Total amount of used log-lines. + }; + + /** + * Print an Info message to the logs. + * @param message The message to log. + */ + static void Info(const char *message); + + /** + * Print a Warning message to the logs. + * @param message The message to log. + */ + static void Warning(const char *message); + + /** + * Print an Error message to the logs. + * @param message The message to log. + */ + static void Error(const char *message); + + /** + * Free the log pointer. + * @note DO NOT CALL YOURSELF; leave it to the internal AI programming. + */ + static void FreeLogPointer(); + +private: + /** + * Internal command to log the message in a common way. + */ + static void Log(AILog::AILogType level, const char *message); +}; + +#endif /* AI_LOG_HPP */ diff --git a/src/ai/api/ai_log.hpp.sq b/src/ai/api/ai_log.hpp.sq new file mode 100644 index 000000000..7b84dc8f1 --- /dev/null +++ b/src/ai/api/ai_log.hpp.sq @@ -0,0 +1,37 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_log.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AILog::AILogType GetParam(ForceType<AILog::AILogType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AILog::AILogType)tmp; } + template <> int Return<AILog::AILogType>(HSQUIRRELVM vm, AILog::AILogType res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AILog to be used as Squirrel parameter */ + template <> AILog *GetParam(ForceType<AILog *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AILog *)instance; } + template <> AILog &GetParam(ForceType<AILog &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AILog *)instance; } + template <> const AILog *GetParam(ForceType<const AILog *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AILog *)instance; } + template <> const AILog &GetParam(ForceType<const AILog &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AILog *)instance; } + template <> int Return<AILog *>(HSQUIRRELVM vm, AILog *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AILog", res, NULL, DefSQDestructorCallback<AILog>); return 1; } +}; // namespace SQConvert + +void SQAILog_Register(Squirrel *engine) { + DefSQClass <AILog> SQAILog("AILog"); + SQAILog.PreRegister(engine); + SQAILog.AddConstructor<void (AILog::*)(), 1>(engine, "x"); + + SQAILog.DefSQConst(engine, AILog::LOG_SQ_ERROR, "LOG_SQ_ERROR"); + SQAILog.DefSQConst(engine, AILog::LOG_ERROR, "LOG_ERROR"); + SQAILog.DefSQConst(engine, AILog::LOG_SQ_INFO, "LOG_SQ_INFO"); + SQAILog.DefSQConst(engine, AILog::LOG_WARNING, "LOG_WARNING"); + SQAILog.DefSQConst(engine, AILog::LOG_INFO, "LOG_INFO"); + + SQAILog.DefSQStaticMethod(engine, &AILog::GetClassName, "GetClassName", 1, "x"); + SQAILog.DefSQStaticMethod(engine, &AILog::Info, "Info", 2, "xs"); + SQAILog.DefSQStaticMethod(engine, &AILog::Warning, "Warning", 2, "xs"); + SQAILog.DefSQStaticMethod(engine, &AILog::Error, "Error", 2, "xs"); + SQAILog.DefSQStaticMethod(engine, &AILog::FreeLogPointer, "FreeLogPointer", 1, "x"); + + SQAILog.PostRegister(engine); +} diff --git a/src/ai/api/ai_map.cpp b/src/ai/api/ai_map.cpp new file mode 100644 index 000000000..2c8547f95 --- /dev/null +++ b/src/ai/api/ai_map.cpp @@ -0,0 +1,62 @@ +/* $Id$ */ + +/** @file ai_map.cpp Implementation of AIMap. */ + +#include "ai_map.hpp" +#include "../../map_func.h" +#include "../../tile_map.h" + +/* static */ bool AIMap::IsValidTile(TileIndex t) +{ + return ::IsValidTile(t); +} + +/* static */ TileIndex AIMap::GetMapSize() +{ + return ::MapSize(); +} + +/* static */ uint32 AIMap::GetMapSizeX() +{ + return ::MapSizeX(); +} + +/* static */ uint32 AIMap::GetMapSizeY() +{ + return ::MapSizeY(); +} + +/* static */ uint32 AIMap::GetTileX(TileIndex t) +{ + return ::TileX(t); +} + +/* static */ uint32 AIMap::GetTileY(TileIndex t) +{ + return ::TileY(t); +} + +/* static */ TileIndex AIMap::GetTileIndex(uint32 x, uint32 y) +{ + return ::TileXY(x, y); +} + +/* static */ uint32 AIMap::DistanceManhattan(TileIndex t1, TileIndex t2) +{ + return ::DistanceManhattan(t1, t2); +} + +/* static */ uint32 AIMap::DistanceMax(TileIndex t1, TileIndex t2) +{ + return ::DistanceMax(t1, t2); +} + +/* static */ uint32 AIMap::DistanceSquare(TileIndex t1, TileIndex t2) +{ + return ::DistanceSquare(t1, t2); +} + +/* static */ uint32 AIMap::DistanceFromEdge(TileIndex t) +{ + return ::DistanceFromEdge(t); +} diff --git a/src/ai/api/ai_map.hpp b/src/ai/api/ai_map.hpp new file mode 100644 index 000000000..f14c360eb --- /dev/null +++ b/src/ai/api/ai_map.hpp @@ -0,0 +1,117 @@ +/* $Id$ */ + +/** @file ai_map.hpp Everything to query and manipulate map metadata. */ + +#ifndef AI_MAP_HPP +#define AI_MAP_HPP + +#include "ai_object.hpp" + +/** + * Class that handles all map related functions. + */ +class AIMap : public AIObject { +public: + static const char *GetClassName() { return "AIMap"; } + + /** + * Checks whether the given tile is valid. + * @param tile The tile to check. + * @return True is the tile it within the boundaries of the map. + */ + static bool IsValidTile(TileIndex tile); + + /** + * Gets the number of tiles in the map. + * @return The size of the map in tiles. + * @post Return value is always positive. + */ + static TileIndex GetMapSize(); + + /** + * Gets the amount of tiles along the SW and NE border. + * @return The length along the SW and NE borders. + * @post Return value is always positive. + */ + static uint32 GetMapSizeX(); + + /** + * Gets the amount of tiles along the SE and NW border. + * @return The length along the SE and NW borders. + * @post Return value is always positive. + */ + static uint32 GetMapSizeY(); + + /** + * Gets the place along the SW/NE border (X-value). + * @param tile The tile to get the X-value of. + * @pre IsValidTile(tile). + * @return The X-value. + * @post Return value is always lower than GetMapSizeX(). + */ + static uint32 GetTileX(TileIndex tile); + + /** + * Gets the place along the SE/NW border (Y-value). + * @param tile The tile to get the Y-value of. + * @pre IsValidTile(tile). + * @return The Y-value. + * @post Return value is always lower than GetMapSizeY(). + */ + static uint32 GetTileY(TileIndex tile); + + /** + * Gets the TileIndex given a x,y-coordinate. + * @param x The X coordinate. + * @param y The Y coordinate. + * @pre x < GetMapSizeX(). + * @pre y < GetMapSizeY(). + * @return The TileIndex for the given (x,y) coordinate. + */ + static TileIndex GetTileIndex(uint32 x, uint32 y); + + /** + * Calculates the Manhattan distance; the difference of + * the X and Y added together. + * @param tile_from The start tile. + * @param tile_to The destination tile. + * @pre IsValidTile(tile_from). + * @pre IsValidTile(tile_to). + * @return The Manhattan distance between the tiles. + */ + static uint32 DistanceManhattan(TileIndex tile_from, TileIndex tile_to); + + /** + * Calculates the distance between two tiles via 1D calculation. + * This means the distance between X or the distance between Y, depending + * on which one is bigger. + * @param tile_from The start tile. + * @param tile_to The destination tile. + * @pre IsValidTile(tile_from). + * @pre IsValidTile(tile_to). + * @return The maximum distance between the tiles. + */ + static uint32 DistanceMax(TileIndex tile_from, TileIndex tile_to); + + /** + * The squared distance between the two tiles. + * This is the distance is the length of the shortest straight line + * between both points. + * @param tile_from The start tile. + * @param tile_to The destination tile. + * @pre IsValidTile(tile_from). + * @pre IsValidTile(tile_to). + * @return The squared distance between the tiles. + */ + static uint32 DistanceSquare(TileIndex tile_from, TileIndex tile_to); + + /** + * Calculates the shortest distance to the edge. + * @param tile From where the distance has to be calculated. + * @pre IsValidTile(tile). + * @return The distances to the closest edge. + */ + static uint32 DistanceFromEdge(TileIndex tile); +}; + +#endif /* AI_MAP_HPP */ diff --git a/src/ai/api/ai_map.hpp.sq b/src/ai/api/ai_map.hpp.sq new file mode 100644 index 000000000..f65368c8f --- /dev/null +++ b/src/ai/api/ai_map.hpp.sq @@ -0,0 +1,34 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_map.hpp" + +namespace SQConvert { + /* Allow AIMap to be used as Squirrel parameter */ + template <> AIMap *GetParam(ForceType<AIMap *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIMap *)instance; } + template <> AIMap &GetParam(ForceType<AIMap &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIMap *)instance; } + template <> const AIMap *GetParam(ForceType<const AIMap *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIMap *)instance; } + template <> const AIMap &GetParam(ForceType<const AIMap &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIMap *)instance; } + template <> int Return<AIMap *>(HSQUIRRELVM vm, AIMap *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIMap", res, NULL, DefSQDestructorCallback<AIMap>); return 1; } +}; // namespace SQConvert + +void SQAIMap_Register(Squirrel *engine) { + DefSQClass <AIMap> SQAIMap("AIMap"); + SQAIMap.PreRegister(engine); + SQAIMap.AddConstructor<void (AIMap::*)(), 1>(engine, "x"); + + SQAIMap.DefSQStaticMethod(engine, &AIMap::GetClassName, "GetClassName", 1, "x"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::IsValidTile, "IsValidTile", 2, "xi"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::GetMapSize, "GetMapSize", 1, "x"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::GetMapSizeX, "GetMapSizeX", 1, "x"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::GetMapSizeY, "GetMapSizeY", 1, "x"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::GetTileX, "GetTileX", 2, "xi"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::GetTileY, "GetTileY", 2, "xi"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::GetTileIndex, "GetTileIndex", 3, "xii"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::DistanceManhattan, "DistanceManhattan", 3, "xii"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::DistanceMax, "DistanceMax", 3, "xii"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::DistanceSquare, "DistanceSquare", 3, "xii"); + SQAIMap.DefSQStaticMethod(engine, &AIMap::DistanceFromEdge, "DistanceFromEdge", 2, "xi"); + + SQAIMap.PostRegister(engine); +} diff --git a/src/ai/api/ai_marine.cpp b/src/ai/api/ai_marine.cpp new file mode 100644 index 000000000..274ab5f6b --- /dev/null +++ b/src/ai/api/ai_marine.cpp @@ -0,0 +1,143 @@ +/* $Id$ */ + +/** @file ai_marine.cpp Implementation of AIMarine. */ + +#include "ai_marine.hpp" +#include "../../openttd.h" +#include "../../command_type.h" +#include "../../variables.h" +#include "../../station_map.h" +#include "../../water_map.h" +#include "../../tile_cmd.h" + + +/* static */ bool AIMarine::IsWaterDepotTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_WATER) && ::GetWaterTileType(tile) == WATER_TILE_DEPOT; +} + +/* static */ bool AIMarine::IsDockTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_STATION) && ::IsDock(tile); +} + +/* static */ bool AIMarine::IsBuoyTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_STATION) && ::IsBuoy(tile); +} + +/* static */ bool AIMarine::IsLockTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_WATER) && ::GetWaterTileType(tile) == WATER_TILE_LOCK; +} + +/* static */ bool AIMarine::IsCanalTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_WATER) && ::IsCanal(tile); +} + +/* static */ bool AIMarine::AreWaterTilesConnected(TileIndex t1, TileIndex t2) +{ + if (!::IsValidTile(t1)) return false; + if (!::IsValidTile(t2)) return false; + + /* Tiles not neighbouring */ + if (::DistanceManhattan(t1, t2) != 1) return false; + if (t1 > t2) Swap(t1, t2); + + uint32 gtts1 = ::GetTileTrackStatus(t1, TRANSPORT_WATER, 0); + uint32 gtts2 = ::GetTileTrackStatus(t2, TRANSPORT_WATER, 0); + + /* Ship can't travel on one of the tiles. */ + if (gtts1 == 0 || gtts2 == 0) return false; + + DiagDirection to_other_tile = (TileX(t1) == TileX(t2)) ? DIAGDIR_SE : DIAGDIR_SW; + + /* Check whether we can 'leave' the tile at the border and 'enter' the other tile at the border */ + return (gtts1 & DiagdirReachesTrackdirs(ReverseDiagDir(to_other_tile))) != 0 && (gtts2 & DiagdirReachesTrackdirs(to_other_tile)) != 0; +} + +/* static */ bool AIMarine::BuildWaterDepot(TileIndex tile, bool vertical) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + + return AIObject::DoCommand(tile, vertical, 0, CMD_BUILD_SHIP_DEPOT); +} + +/* static */ bool AIMarine::BuildDock(TileIndex tile, bool join_adjacent) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + + return AIObject::DoCommand(tile, join_adjacent ? 0 : 1, INVALID_STATION << 16, CMD_BUILD_DOCK); +} + +/* static */ bool AIMarine::BuildBuoy(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_BUILD_BUOY); +} + +/* static */ bool AIMarine::BuildLock(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_BUILD_LOCK); +} + +/* static */ bool AIMarine::BuildCanal(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + + return AIObject::DoCommand(tile, tile, 0, CMD_BUILD_CANAL); +} + +/* static */ bool AIMarine::RemoveWaterDepot(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, IsWaterDepotTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR); +} + +/* static */ bool AIMarine::RemoveDock(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, IsDockTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR); +} + +/* static */ bool AIMarine::RemoveBuoy(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, IsBuoyTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR); +} + +/* static */ bool AIMarine::RemoveLock(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, IsLockTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR); +} + +/* static */ bool AIMarine::RemoveCanal(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, IsCanalTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR); +} diff --git a/src/ai/api/ai_marine.hpp b/src/ai/api/ai_marine.hpp new file mode 100644 index 000000000..9f871887d --- /dev/null +++ b/src/ai/api/ai_marine.hpp @@ -0,0 +1,187 @@ +/* $Id$ */ + +/** @file ai_marine.hpp Everything to query and build marine. */ + +#ifndef AI_MARINE_HPP +#define AI_MARINE_HPP + +#include "ai_object.hpp" +#include "ai_error.hpp" + +/** + * Class that handles all marine related functions. + */ +class AIMarine : public AIObject { +public: + static const char *GetClassName() { return "AIMarine"; } + + /** + * All marine related error messages. + */ + enum ErrorMessages { + /** Base for marine related errors */ + ERR_MARINE_BASE = AIError::ERR_CAT_MARINE << AIError::ERR_CAT_BIT_SIZE, + + /** Infrastructure must be built on water */ + ERR_MARINE_MUST_BE_BUILT_ON_WATER, // [STR_3801_MUST_BE_BUILT_ON_WATER] + }; + + /** + * Checks whether the given tile is actually a tile with a water depot. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a water depot. + */ + static bool IsWaterDepotTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a dock. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a dock. + */ + static bool IsDockTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a buoy. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a buoy. + */ + static bool IsBuoyTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a lock. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a lock. + */ + static bool IsLockTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a canal. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a canal. + */ + static bool IsCanalTile(TileIndex tile); + + /** + * Checks whether the given tiles are directly connected, i.e. whether + * a ship vehicle can travel from the center of the first tile to the + * center of the second tile. + * @param tile_from The source tile. + * @param tile_to The destination tile. + * @pre AIMap::IsValidTile(tile_from). + * @pre AIMap::IsValidTile(tile_to). + * @pre 'tile_from' and 'tile_to' are directly neighbouring tiles. + * @return True if and only if a ship can go from tile_from to tile_to. + */ + static bool AreWaterTilesConnected(TileIndex tile_from, TileIndex tile_to); + + /** + * Builds a water depot on tile. + * @param tile The tile where the water depot will be build. + * @param vertical If true, depot will be vertical, else horizontal. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_SITE_UNSUITABLE + * @exception AIMarine::ERR_MARINE_MUST_BE_BUILT_ON_WATER + * @return Whether the water depot has been/can be build or not. + * @note A WaterDepot is 1 tile in width, and 2 tiles in length. + */ + static bool BuildWaterDepot(TileIndex tile, bool vertical); + + /** + * Builds a dock where tile is the tile still on land. + * @param tile The tile still on land of the dock. + * @param join_adjacent When building next to an other station, don't create a new station when this flag is true. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_SITE_UNSUITABLE + * @exception AIStation::ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION + * @exception AIStation::ERR_STATION_TOO_MANY_STATIONS + * @return Whether the dock has been/can be build or not. + */ + static bool BuildDock(TileIndex tile, bool join_adjacent); + + /** + * Builds a buoy on tile. + * @param tile The tile where the buoy will be build. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_SITE_UNSUITABLE + * @exception AIStation::ERR_STATION_TOO_MANY_STATIONS + * @return Whether the buoy has been/can be build or not. + */ + static bool BuildBuoy(TileIndex tile); + + /** + * Builds a lock on tile. + * @param tile The tile where the lock will be build. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_LAND_SLOPED_WRONG + * @exception AIError::ERR_SITE_UNSUITABLE + * @return Whether the lock has been/can be build or not. + */ + static bool BuildLock(TileIndex tile); + + /** + * Builds a canal on tile. + * @param tile The tile where the canal will be build. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_LAND_SLOPED_WRONG + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIError::ERR_ALREADY_BUILT + * @return Whether the canal has been/can be build or not. + */ + static bool BuildCanal(TileIndex tile); + + /** + * Removes a water depot. + * @param tile Any tile of the water depot. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return Whether the water depot has been/can be removed or not. + */ + static bool RemoveWaterDepot(TileIndex tile); + + /** + * Removes a dock. + * @param tile Any tile of the dock. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return Whether the dock has been/can be removed or not. + */ + static bool RemoveDock(TileIndex tile); + + /** + * Removes a buoy. + * @param tile Any tile of the buoy. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return Whether the buoy has been/can be removed or not. + */ + static bool RemoveBuoy(TileIndex tile); + + /** + * Removes a lock. + * @param tile Any tile of the lock. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return Whether the lock has been/can be removed or not. + */ + static bool RemoveLock(TileIndex tile); + + /** + * Removes a canal. + * @param tile Any tile of the canal. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return Whether the canal has been/can be removed or not. + */ + static bool RemoveCanal(TileIndex tile); +}; + +#endif /* AI_MARINE_HPP */ diff --git a/src/ai/api/ai_marine.hpp.sq b/src/ai/api/ai_marine.hpp.sq new file mode 100644 index 000000000..269c99604 --- /dev/null +++ b/src/ai/api/ai_marine.hpp.sq @@ -0,0 +1,50 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_marine.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIMarine::ErrorMessages GetParam(ForceType<AIMarine::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIMarine::ErrorMessages)tmp; } + template <> int Return<AIMarine::ErrorMessages>(HSQUIRRELVM vm, AIMarine::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIMarine to be used as Squirrel parameter */ + template <> AIMarine *GetParam(ForceType<AIMarine *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIMarine *)instance; } + template <> AIMarine &GetParam(ForceType<AIMarine &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIMarine *)instance; } + template <> const AIMarine *GetParam(ForceType<const AIMarine *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIMarine *)instance; } + template <> const AIMarine &GetParam(ForceType<const AIMarine &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIMarine *)instance; } + template <> int Return<AIMarine *>(HSQUIRRELVM vm, AIMarine *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIMarine", res, NULL, DefSQDestructorCallback<AIMarine>); return 1; } +}; // namespace SQConvert + +void SQAIMarine_Register(Squirrel *engine) { + DefSQClass <AIMarine> SQAIMarine("AIMarine"); + SQAIMarine.PreRegister(engine); + SQAIMarine.AddConstructor<void (AIMarine::*)(), 1>(engine, "x"); + + SQAIMarine.DefSQConst(engine, AIMarine::ERR_MARINE_BASE, "ERR_MARINE_BASE"); + SQAIMarine.DefSQConst(engine, AIMarine::ERR_MARINE_MUST_BE_BUILT_ON_WATER, "ERR_MARINE_MUST_BE_BUILT_ON_WATER"); + + AIError::RegisterErrorMap(STR_3801_MUST_BE_BUILT_ON_WATER, AIMarine::ERR_MARINE_MUST_BE_BUILT_ON_WATER); + + AIError::RegisterErrorMapString(AIMarine::ERR_MARINE_MUST_BE_BUILT_ON_WATER, "ERR_MARINE_MUST_BE_BUILT_ON_WATER"); + + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::GetClassName, "GetClassName", 1, "x"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::IsWaterDepotTile, "IsWaterDepotTile", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::IsDockTile, "IsDockTile", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::IsBuoyTile, "IsBuoyTile", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::IsLockTile, "IsLockTile", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::IsCanalTile, "IsCanalTile", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::AreWaterTilesConnected, "AreWaterTilesConnected", 3, "xii"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::BuildWaterDepot, "BuildWaterDepot", 3, "xib"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::BuildDock, "BuildDock", 3, "xib"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::BuildBuoy, "BuildBuoy", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::BuildLock, "BuildLock", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::BuildCanal, "BuildCanal", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::RemoveWaterDepot, "RemoveWaterDepot", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::RemoveDock, "RemoveDock", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::RemoveBuoy, "RemoveBuoy", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::RemoveLock, "RemoveLock", 2, "xi"); + SQAIMarine.DefSQStaticMethod(engine, &AIMarine::RemoveCanal, "RemoveCanal", 2, "xi"); + + SQAIMarine.PostRegister(engine); +} diff --git a/src/ai/api/ai_object.cpp b/src/ai/api/ai_object.cpp new file mode 100644 index 000000000..664c24ecc --- /dev/null +++ b/src/ai/api/ai_object.cpp @@ -0,0 +1,264 @@ +/* $Id$ */ + +/** @file ai_object.cpp Implementation of AIObject. */ + +#include "ai_object.hpp" +#include "ai_log.hpp" +#include "ai_error.hpp" +#include "table/strings.h" +#include "../../openttd.h" +#include "../../command_func.h" +#include "../../map_func.h" +#include "../../network/network.h" +#include "../../company_func.h" +#include "../../signs_func.h" +#include "../../tunnelbridge.h" +#include "../../vehicle_func.h" +#include "../../group.h" +#include "../ai.hpp" +#include "ai_controller.hpp" +#include "../ai_storage.hpp" +#include "../ai_instance.hpp" + +#include <vector> + +static AIStorage *GetStorage() +{ + return AIInstance::GetStorage(); +} + +void AIObject::SetDoCommandDelay(uint ticks) +{ + assert(ticks > 0); + GetStorage()->delay = ticks; +} + +uint AIObject::GetDoCommandDelay() +{ + return GetStorage()->delay; +} + +void AIObject::SetDoCommandMode(AIModeProc *proc, AIObject *instance) +{ + GetStorage()->mode = proc; + GetStorage()->mode_instance = instance; +} + +AIModeProc *AIObject::GetDoCommandMode() +{ + return GetStorage()->mode; +} + +AIObject *AIObject::GetDoCommandModeInstance() +{ + return GetStorage()->mode_instance; +} + +void AIObject::SetDoCommandCosts(Money value) +{ + GetStorage()->costs = CommandCost(value); +} + +void AIObject::IncreaseDoCommandCosts(Money value) +{ + GetStorage()->costs.AddCost(value); +} + +Money AIObject::GetDoCommandCosts() +{ + return GetStorage()->costs.GetCost(); +} + +void AIObject::SetLastError(AIErrorType last_error) +{ + GetStorage()->last_error = last_error; +} + +AIErrorType AIObject::GetLastError() +{ + return GetStorage()->last_error; +} + +void AIObject::SetLastCost(Money last_cost) +{ + GetStorage()->last_cost = last_cost; +} + +Money AIObject::GetLastCost() +{ + return GetStorage()->last_cost; +} + +void AIObject::SetRoadType(RoadType road_type) +{ + GetStorage()->road_type = road_type; +} + +RoadType AIObject::GetRoadType() +{ + return GetStorage()->road_type; +} + +void AIObject::SetRailType(RailType rail_type) +{ + GetStorage()->rail_type = rail_type; +} + +RailType AIObject::GetRailType() +{ + return GetStorage()->rail_type; +} + +void AIObject::SetLastCommandRes(bool res) +{ + GetStorage()->last_command_res = res; + /* Also store the results of various global variables */ + SetNewVehicleID(_new_vehicle_id); + SetNewSignID(_new_sign_id); + SetNewTunnelEndtile(_build_tunnel_endtile); + SetNewGroupID(_new_group_id); +} + +bool AIObject::GetLastCommandRes() +{ + return GetStorage()->last_command_res; +} + +void AIObject::SetNewVehicleID(VehicleID vehicle_id) +{ + GetStorage()->new_vehicle_id = vehicle_id; +} + +VehicleID AIObject::GetNewVehicleID() +{ + return GetStorage()->new_vehicle_id; +} + +void AIObject::SetNewSignID(SignID sign_id) +{ + GetStorage()->new_sign_id = sign_id; +} + +SignID AIObject::GetNewSignID() +{ + return GetStorage()->new_sign_id; +} + +void AIObject::SetNewTunnelEndtile(TileIndex tile) +{ + GetStorage()->new_tunnel_endtile = tile; +} + +TileIndex AIObject::GetNewTunnelEndtile() +{ + return GetStorage()->new_tunnel_endtile; +} + +void AIObject::SetNewGroupID(GroupID group_id) +{ + GetStorage()->new_group_id = group_id; +} + +GroupID AIObject::GetNewGroupID() +{ + return GetStorage()->new_group_id; +} + +void AIObject::SetAllowDoCommand(bool allow) +{ + GetStorage()->allow_do_command = allow; +} + +bool AIObject::GetAllowDoCommand() +{ + return GetStorage()->allow_do_command; +} + +void *&AIObject::GetEventPointer() +{ + return GetStorage()->event_data; +} + +void *&AIObject::GetLogPointer() +{ + return GetStorage()->log_data; +} + +void AIObject::SetCallbackVariable(int index, int value) +{ + if ((size_t)index >= GetStorage()->callback_value.size()) GetStorage()->callback_value.resize(index + 1); + GetStorage()->callback_value[index] = value; +} + +int AIObject::GetCallbackVariable(int index) +{ + return GetStorage()->callback_value[index]; +} + +bool AIObject::DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint cmd, const char *text, AISuspendCallbackProc *callback) +{ + if (AIObject::GetAllowDoCommand() == false) { + AILog::Error("You are not allowed to execute any DoCommand (even indirect) in your constructor, Save(), and Load().\n"); + return false; + } + + CompanyID old_company; + CommandCost res; + + /* Set the default callback to return a true/false result of the DoCommand */ + if (callback == NULL) callback = &AIInstance::DoCommandReturn; + + /* Make sure the last error is reset, so we don't give faulty warnings */ + SetLastError(AIError::ERR_NONE); + + /* First, do a test-run to see if we can do this */ + res = ::DoCommand(tile, p1, p2, CommandFlagsToDCFlags(GetCommandFlags(cmd)), cmd, text); + /* The command failed, so return */ + if (::CmdFailed(res)) { + SetLastError(AIError::StringToError(_error_message)); + return false; + } + + /* Check what the callback wants us to do */ + if (GetDoCommandMode() != NULL && !GetDoCommandMode()(tile, p1, p2, cmd, res)) { + IncreaseDoCommandCosts(res.GetCost()); + return true; + } + +#ifdef ENABLE_NETWORK + /* Send the command */ + if (_networking) { + /* NetworkSend_Command needs _local_company to be set correctly, so + * adjust it, and put it back right after the function */ + old_company = _local_company; + _local_company = _current_company; + ::NetworkSend_Command(tile, p1, p2, cmd, CcAI, text); + _local_company = old_company; + SetLastCost(res.GetCost()); + + /* Suspend the AI till the command is really executed */ + throw AI_VMSuspend(-(int)GetDoCommandDelay(), callback); + } else { +#else + { +#endif + /* For SinglePlayer we execute the command immediatly */ + if (!::DoCommandP(tile, p1, p2, cmd, NULL, text)) res = CMD_ERROR; + SetLastCommandRes(!::CmdFailed(res)); + + if (::CmdFailed(res)) { + SetLastError(AIError::StringToError(_error_message)); + return false; + } + SetLastCost(res.GetCost()); + IncreaseDoCommandCosts(res.GetCost()); + + /* Suspend the AI player for 1+ ticks, so it simulates multiplayer. This + * both avoids confusion when a developer launched his AI in a + * multiplayer game, but also gives time for the GUI and human player + * to interact with the game. */ + throw AI_VMSuspend(GetDoCommandDelay(), callback); + } + + NOT_REACHED(); +} diff --git a/src/ai/api/ai_object.hpp b/src/ai/api/ai_object.hpp new file mode 100644 index 000000000..9dcb0f4cc --- /dev/null +++ b/src/ai/api/ai_object.hpp @@ -0,0 +1,202 @@ +/* $Id$ */ + +/** @file ai_object.hpp Main object, on which all objects depend. */ + +#ifndef AI_OBJECT_HPP +#define AI_OBJECT_HPP + +#include "../../stdafx.h" +#include "../../misc/countedptr.hpp" +#include "../../road_type.h" +#include "../../rail_type.h" + +#include "ai_types.hpp" + +/** + * The callback function when an AI suspends. + */ +typedef void (AISuspendCallbackProc)(class AIInstance *instance); + +/** + * The callback function for Mode-classes. + */ +typedef bool (AIModeProc)(TileIndex tile, uint32 p1, uint32 p2, uint cmd, CommandCost costs); + +/** + * Uper-parent object of all API classes. You should never use this class in + * your AI, as it doesn't publish any public functions. It is used + * internally to have a common place to handle general things, like internal + * command processing, and command-validation checks. + */ +class AIObject : public SimpleCountedObject { +friend void CcAI(bool success, TileIndex tile, uint32 p1, uint32 p2); +friend class AIInstance; +friend class AIController; +protected: + /** + * Executes a raw DoCommand for the AI. + */ + static bool DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint cmd, const char *text = NULL, AISuspendCallbackProc *callback = NULL); + + /** + * Sets the DoCommand costs counter to a value. + */ + static void SetDoCommandCosts(Money value); + + /** + * Increase the current value of the DoCommand costs counter. + */ + static void IncreaseDoCommandCosts(Money value); + + /** + * Get the current DoCommand costs counter. + */ + static Money GetDoCommandCosts(); + + /** + * Set the DoCommand last error. + */ + static void SetLastError(AIErrorType last_error); + + /** + * Get the DoCommand last error. + */ + static AIErrorType GetLastError(); + + /** + * Set the road type. + */ + static void SetRoadType(RoadType road_type); + + /** + * Get the road type. + */ + static RoadType GetRoadType(); + + /** + * Set the rail type. + */ + static void SetRailType(RailType rail_type); + + /** + * Get the rail type. + */ + static RailType GetRailType(); + + /** + * Set the current mode of your AI to this proc. + */ + static void SetDoCommandMode(AIModeProc *proc, AIObject *instance); + + /** + * Get the current mode your AI is currently under. + */ + static AIModeProc *GetDoCommandMode(); + + /** + * Get the instance of the current mode your AI is currently under. + */ + static AIObject *GetDoCommandModeInstance(); + + /** + * Set the delay of the DoCommand. + */ + static void SetDoCommandDelay(uint ticks); + + /** + * Get the delay of the DoCommand. + */ + static uint GetDoCommandDelay(); + + /** + * Get the latest result of a DoCommand. + */ + static bool GetLastCommandRes(); + + /** + * Get the latest stored new_vehicle_id. + */ + static VehicleID GetNewVehicleID(); + + /** + * Get the latest stored new_sign_id. + */ + static SignID GetNewSignID(); + + /** + * Get the latest stored new_tunnel_endtile. + */ + static TileIndex GetNewTunnelEndtile(); + + /** + * Get the latest stored new_group_id. + */ + static GroupID GetNewGroupID(); + + /** + * Get the latest stored allow_do_command. + * If this is false, you are not allowed to do any DoCommands. + */ + static bool GetAllowDoCommand(); + + /** + * Get the pointer to store event data in. + */ + static void *&GetEventPointer(); + + static void SetLastCost(Money last_cost); + static Money GetLastCost(); + static void SetCallbackVariable(int index, int value); + static int GetCallbackVariable(int index); + +public: + /** + * Store the latest result of a DoCommand per company. + * @note NEVER use this yourself in your AI! + * @param res The result of the last command. + */ + static void SetLastCommandRes(bool res); + + /** + * Store a new_vehicle_id per company. + * @note NEVER use this yourself in your AI! + * @param vehicle_id The new VehicleID. + */ + static void SetNewVehicleID(VehicleID vehicle_id); + + /** + * Store a new_sign_id per company. + * @note NEVER use this yourself in your AI! + * @param sign_id The new SignID. + */ + static void SetNewSignID(SignID sign_id); + + /** + * Store a new_tunnel_endtile per company. + * @note NEVER use this yourself in your AI! + * @param tile The new TileIndex. + */ + static void SetNewTunnelEndtile(TileIndex tile); + + /** + * Store a new_group_id per company. + * @note NEVER use this yourself in your AI! + * @param group_id The new GroupID. + */ + static void SetNewGroupID(GroupID group_id); + + /** + * Store a allow_do_command per company. + * @note NEVER use this yourself in your AI! + * @param allow The new allow. + */ + static void SetAllowDoCommand(bool allow); + + /** + * Get the pointer to store log message in. + * @note NEVER use this yourself in your AI! + */ + static void *&GetLogPointer(); +}; + +#endif /* AI_OBJECT_HPP */ diff --git a/src/ai/api/ai_order.cpp b/src/ai/api/ai_order.cpp new file mode 100644 index 000000000..f48c5e392 --- /dev/null +++ b/src/ai/api/ai_order.cpp @@ -0,0 +1,296 @@ +/* $Id$ */ + +/** @file ai_order.cpp Implementation of AIOrder. */ + +#include "ai_order.hpp" +#include "ai_map.hpp" +#include "ai_vehicle.hpp" +#include "../ai_instance.hpp" +#include "../../openttd.h" +#include "../../debug.h" +#include "../../vehicle_base.h" +#include "../../depot_base.h" +#include "../../landscape.h" +#include "../../rail_map.h" +#include "../../road_map.h" +#include "../../station_map.h" +#include "../../water_map.h" +#include "../../waypoint.h" + +/** + * Gets the order type given a tile + * @param t the tile to get the order from + * @return the order type, or OT_END when there is no order + */ +static OrderType GetOrderTypeByTile(TileIndex t) +{ + if (!::IsValidTile(t)) return OT_END; + + switch (::GetTileType(t)) { + default: break; + case MP_STATION: return OT_GOTO_STATION; break; + case MP_WATER: if (::IsShipDepot(t)) return OT_GOTO_DEPOT; break; + case MP_ROAD: if (::GetRoadTileType(t) == ROAD_TILE_DEPOT) return OT_GOTO_DEPOT; break; + case MP_RAILWAY: + switch (::GetRailTileType(t)) { + case RAIL_TILE_DEPOT: return OT_GOTO_DEPOT; + case RAIL_TILE_WAYPOINT: return OT_GOTO_WAYPOINT; + default: break; + } + break; + } + + return OT_END; +} + +/* static */ bool AIOrder::IsValidVehicleOrder(VehicleID vehicle_id, OrderPosition order_position) +{ + return AIVehicle::IsValidVehicle(vehicle_id) && order_position >= 0 && (order_position < ::GetVehicle(vehicle_id)->GetNumOrders() || order_position == CURRENT_ORDER); +} + +/* static */ AIOrder::OrderPosition AIOrder::ResolveOrderPosition(VehicleID vehicle_id, OrderPosition order_position) +{ + if (!AIVehicle::IsValidVehicle(vehicle_id)) return INVALID_ORDER; + + if (order_position == CURRENT_ORDER) return (AIOrder::OrderPosition)::GetVehicle(vehicle_id)->cur_order_index; + return (order_position >= 0 && order_position < ::GetVehicle(vehicle_id)->GetNumOrders()) ? order_position : INVALID_ORDER; +} + + +/* static */ bool AIOrder::AreOrderFlagsValid(TileIndex destination, AIOrderFlags order_flags) +{ + switch (::GetOrderTypeByTile(destination)) { + case OT_GOTO_STATION: + return ((order_flags & ~(AIOF_NON_STOP_FLAGS | AIOF_UNLOAD_FLAGS | AIOF_LOAD_FLAGS)) == 0) && + /* Test the different mutual exclusive flags. */ + (((order_flags & AIOF_TRANSFER) == 0) || ((order_flags & AIOF_UNLOAD) == 0)) && + (((order_flags & AIOF_TRANSFER) == 0) || ((order_flags & AIOF_NO_UNLOAD) == 0)) && + (((order_flags & AIOF_UNLOAD) == 0) || ((order_flags & AIOF_NO_UNLOAD) == 0)) && + (((order_flags & AIOF_UNLOAD) == 0) || ((order_flags & AIOF_NO_UNLOAD) == 0)) && + (((order_flags & AIOF_NO_UNLOAD) == 0) || ((order_flags & AIOF_NO_LOAD) == 0)) && + (((order_flags & AIOF_FULL_LOAD_ANY) == 0) || ((order_flags & AIOF_NO_LOAD) == 0)); + + case OT_GOTO_DEPOT: return (order_flags & ~(AIOF_NON_STOP_FLAGS | AIOF_SERVICE_IF_NEEDED)) == 0; + case OT_GOTO_WAYPOINT: return (order_flags & ~(AIOF_NON_STOP_FLAGS)) == 0; + default: return false; + } +} + +/* static */ int32 AIOrder::GetOrderCount(VehicleID vehicle_id) +{ + return AIVehicle::IsValidVehicle(vehicle_id) ? ::GetVehicle(vehicle_id)->GetNumOrders() : -1; +} + +/* static */ TileIndex AIOrder::GetOrderDestination(VehicleID vehicle_id, OrderPosition order_position) +{ + if (!IsValidVehicleOrder(vehicle_id, order_position)) return INVALID_TILE; + + const Order *order; + const Vehicle *v = ::GetVehicle(vehicle_id); + if (order_position == CURRENT_ORDER) { + order = &v->current_order; + } else { + order = v->GetFirstOrder(); + for (int i = 0; i < order_position; i++) order = order->next; + } + + switch (order->GetType()) { + case OT_GOTO_DEPOT: + if (v->type != VEH_AIRCRAFT) return ::GetDepot(order->GetDestination())->xy; + /* FALL THROUGH: aircraft's hangars are referenced by StationID, not DepotID */ + + case OT_GOTO_STATION: return ::GetStation(order->GetDestination())->xy; + case OT_GOTO_WAYPOINT: return ::GetWaypoint(order->GetDestination())->xy; + default: return INVALID_TILE; + } +} + +/* static */ AIOrder::AIOrderFlags AIOrder::GetOrderFlags(VehicleID vehicle_id, OrderPosition order_position) +{ + if (!IsValidVehicleOrder(vehicle_id, order_position)) return AIOF_INVALID; + + const Order *order; + if (order_position == CURRENT_ORDER) { + order = &::GetVehicle(vehicle_id)->current_order; + } else { + order = ::GetVehicle(vehicle_id)->GetFirstOrder(); + for (int i = 0; i < order_position; i++) order = order->next; + } + + AIOrderFlags order_flags = AIOF_NONE; + order_flags |= (AIOrderFlags)order->GetNonStopType(); + switch (order->GetType()) { + case OT_GOTO_DEPOT: + if (order->GetDepotOrderType() & ODTFB_SERVICE) order_flags |= AIOF_SERVICE_IF_NEEDED; + break; + + case OT_GOTO_STATION: + order_flags |= (AIOrderFlags)(order->GetLoadType() << 5); + order_flags |= (AIOrderFlags)(order->GetUnloadType() << 2); + break; + + default: break; + } + + return order_flags; +} + +/* static */ bool AIOrder::AppendOrder(VehicleID vehicle_id, TileIndex destination, AIOrderFlags order_flags) +{ + EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id)); + return InsertOrder(vehicle_id, (AIOrder::OrderPosition)::GetVehicle(vehicle_id)->GetNumOrders(), destination, order_flags); +} + +/* static */ bool AIOrder::InsertOrder(VehicleID vehicle_id, OrderPosition order_position, TileIndex destination, AIOrder::AIOrderFlags order_flags) +{ + /* IsValidVehicleOrder is not good enough because it does not allow appending. */ + if (order_position == CURRENT_ORDER) order_position = AIOrder::ResolveOrderPosition(vehicle_id, order_position); + + EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id)); + EnforcePrecondition(false, order_position >= 0 && order_position <= ::GetVehicle(vehicle_id)->GetNumOrders()); + EnforcePrecondition(false, AreOrderFlagsValid(destination, order_flags)); + + Order order; + switch (::GetOrderTypeByTile(destination)) { + case OT_GOTO_DEPOT: + order.MakeGoToDepot(::GetDepotByTile(destination)->index, (OrderDepotTypeFlags)(ODTFB_PART_OF_ORDERS | ((order_flags & AIOF_SERVICE_IF_NEEDED) ? ODTFB_SERVICE : 0))); + break; + + case OT_GOTO_STATION: + order.MakeGoToStation(::GetStationIndex(destination)); + order.SetLoadType((OrderLoadFlags)GB(order_flags, 5, 3)); + order.SetUnloadType((OrderUnloadFlags)GB(order_flags, 2, 3)); + break; + + case OT_GOTO_WAYPOINT: + order.MakeGoToWaypoint(::GetWaypointIndex(destination)); + break; + + default: + return false; + } + + order.SetNonStopType((OrderNonStopFlags)GB(order_flags, 0, 2)); + + return AIObject::DoCommand(0, vehicle_id | (order_position << 16), order.Pack(), CMD_INSERT_ORDER); +} + +/* static */ bool AIOrder::RemoveOrder(VehicleID vehicle_id, OrderPosition order_position) +{ + order_position = AIOrder::ResolveOrderPosition(vehicle_id, order_position); + + EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position)); + + return AIObject::DoCommand(0, vehicle_id, order_position, CMD_DELETE_ORDER); +} + +/** + * Callback handler as ChangeOrder possibly needs multiple DoCommand calls + * to be able to set all order flags correctly. As we need to wait till the + * command has completed before we know the next bits to change we need to + * call the function multiple times. Each time it'll reduce the difference + * between the wanted and the current order. + * @param instance The AI we are doing the callback for. + */ +static void _DoCommandReturnChangeOrder(class AIInstance *instance) +{ + AIObject::SetLastCommandRes(AIOrder::_ChangeOrder()); + AIInstance::DoCommandReturn(instance); +} + +/* static */ bool AIOrder::_ChangeOrder() +{ + /* Make sure we don't go into an infinite loop */ + int retry = AIObject::GetCallbackVariable(3) - 1; + if (retry < 0) { + DEBUG(ai, 0, "Possible infinite loop in ChangeOrder detected"); + return false; + } + AIObject::SetCallbackVariable(3, retry); + + VehicleID vehicle_id = (VehicleID)AIObject::GetCallbackVariable(0); + OrderPosition order_position = (OrderPosition)AIObject::GetCallbackVariable(1); + AIOrderFlags order_flags = (AIOrderFlags)AIObject::GetCallbackVariable(2); + + order_position = AIOrder::ResolveOrderPosition(vehicle_id, order_position); + + EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position)); + EnforcePrecondition(false, AreOrderFlagsValid(GetOrderDestination(vehicle_id, order_position), order_flags)); + + Order *order = ::GetVehicle(vehicle_id)->GetFirstOrder(); + for (int i = 0; i < order_position; i++) order = order->next; + + AIOrderFlags current = GetOrderFlags(vehicle_id, order_position); + + if ((current & AIOF_NON_STOP_FLAGS) != (order_flags & AIOF_NON_STOP_FLAGS)) { + return AIObject::DoCommand(0, vehicle_id | (order_position << 16), (order_flags & AIOF_NON_STOP_FLAGS) << 4 | MOF_NON_STOP, CMD_MODIFY_ORDER, NULL, &_DoCommandReturnChangeOrder); + } + + switch (order->GetType()) { + case OT_GOTO_DEPOT: + if ((current & AIOF_SERVICE_IF_NEEDED) != (order_flags & AIOF_SERVICE_IF_NEEDED)) { + return AIObject::DoCommand(0, vehicle_id | (order_position << 16), MOF_DEPOT_ACTION, CMD_MODIFY_ORDER, NULL, &_DoCommandReturnChangeOrder); + } + break; + + case OT_GOTO_STATION: + if ((current & AIOF_UNLOAD_FLAGS) != (order_flags & AIOF_UNLOAD_FLAGS)) { + return AIObject::DoCommand(0, vehicle_id | (order_position << 16), (order_flags & AIOF_UNLOAD_FLAGS) << 2 | MOF_UNLOAD, CMD_MODIFY_ORDER, NULL, &_DoCommandReturnChangeOrder); + } + if ((current & AIOF_LOAD_FLAGS) != (order_flags & AIOF_LOAD_FLAGS)) { + return AIObject::DoCommand(0, vehicle_id | (order_position << 16), (order_flags & AIOF_LOAD_FLAGS) >> 1 | MOF_LOAD, CMD_MODIFY_ORDER, NULL, &_DoCommandReturnChangeOrder); + } + break; + + default: break; + } + + assert(GetOrderFlags(vehicle_id, order_position) == order_flags); + + return true; +} + +/* static */ bool AIOrder::ChangeOrder(VehicleID vehicle_id, OrderPosition order_position, AIOrder::AIOrderFlags order_flags) +{ + AIObject::SetCallbackVariable(0, vehicle_id); + AIObject::SetCallbackVariable(1, order_position); + AIObject::SetCallbackVariable(2, order_flags); + /* In case another client(s) change orders at the same time we could + * end in an infinite loop. This stops that from happening ever. */ + AIObject::SetCallbackVariable(3, 8); + return AIOrder::_ChangeOrder(); +} + +/* static */ bool AIOrder::MoveOrder(VehicleID vehicle_id, OrderPosition order_position_move, OrderPosition order_position_target) +{ + order_position_move = AIOrder::ResolveOrderPosition(vehicle_id, order_position_move); + order_position_target = AIOrder::ResolveOrderPosition(vehicle_id, order_position_target); + + EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position_move)); + EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position_target)); + + return AIObject::DoCommand(0, vehicle_id, order_position_move | (order_position_target << 16), CMD_MOVE_ORDER); +} + +/* static */ bool AIOrder::CopyOrders(VehicleID vehicle_id, VehicleID main_vehicle_id) +{ + EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id)); + EnforcePrecondition(false, AIVehicle::IsValidVehicle(main_vehicle_id)); + + return AIObject::DoCommand(0, vehicle_id | (main_vehicle_id << 16), CO_COPY, CMD_CLONE_ORDER); +} + +/* static */ bool AIOrder::ShareOrders(VehicleID vehicle_id, VehicleID main_vehicle_id) +{ + EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id)); + EnforcePrecondition(false, AIVehicle::IsValidVehicle(main_vehicle_id)); + + return AIObject::DoCommand(0, vehicle_id | (main_vehicle_id << 16), CO_SHARE, CMD_CLONE_ORDER); +} + +/* static */ bool AIOrder::UnshareOrders(VehicleID vehicle_id) +{ + EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id)); + + return AIObject::DoCommand(0, vehicle_id, CO_UNSHARE, CMD_CLONE_ORDER); +} diff --git a/src/ai/api/ai_order.hpp b/src/ai/api/ai_order.hpp new file mode 100644 index 000000000..fbda26892 --- /dev/null +++ b/src/ai/api/ai_order.hpp @@ -0,0 +1,253 @@ +/* $Id$ */ + +/** @file ai_order.hpp Everything to query and build orders. */ + +#ifndef AI_ORDER_HPP +#define AI_ORDER_HPP + +#include "ai_object.hpp" +#include "ai_error.hpp" + +/** + * Class that handles all order related functions. + */ +class AIOrder : public AIObject { +public: + static const char *GetClassName() { return "AIOrder"; } + + /** + * All order related error messages. + */ + enum ErrorMessages { + /** Base for all order related errors */ + ERR_ORDER_BASE = AIError::ERR_CAT_ORDER << AIError::ERR_CAT_BIT_SIZE, + + /** No more space for orders */ + ERR_ORDER_TOO_MANY, // [STR_8831_NO_MORE_SPACE_FOR_ORDERS] + + /** Destination of new order is to far away from the previous order */ + ERR_ORDER_TOO_FAR_AWAY_FROM_PREVIOUS_DESTINATION, // [STR_0210_TOO_FAR_FROM_PREVIOUS_DESTINATIO] + }; + + /** + * Flags that can be used to modify the behaviour of orders. + */ + enum AIOrderFlags { + /** Just go to the station/depot, stop unload if possible and load if needed. */ + AIOF_NONE = 0, + + /** Do not stop at the stations that are passed when going to the destination. Only for trains and road vehicles. */ + AIOF_NON_STOP_INTERMEDIATE = 1 << 0, + /** Do not stop at the destionation station. Only for trains and road vehicles. */ + AIOF_NON_STOP_DESTINATION = 1 << 1, + + /** Always unload the vehicle; only for stations. Cannot be set when AIOF_TRANSFER or AIOF_NO_UNLOAD is set. */ + AIOF_UNLOAD = 1 << 2, + /** Transfer instead of deliver the goods; only for stations. Cannot be set when AIOF_UNLOAD or AIOF_NO_UNLOAD is set. */ + AIOF_TRANSFER = 1 << 3, + /** Never unload the vehicle; only for stations. Cannot be set when AIOF_UNLOAD, AIOF_TRANSFER or AIOF_NO_LOAD is set. */ + AIOF_NO_UNLOAD = 1 << 4, + + /** Wait till the vehicle is fully loaded; only for stations. Cannot be set when AIOF_NO_LOAD is set. */ + AIOF_FULL_LOAD = 2 << 5, + /** Wait till at least one cargo of the vehicle is fully loaded; only for stations. Cannot be set when AIOF_NO_LOAD is set. */ + AIOF_FULL_LOAD_ANY = 3 << 5, + /** Do not load any cargo; only for stations. Cannot be set when AIOF_NO_UNLOAD, AIOF_FULL_LOAD or AIOF_FULL_LOAD_ANY is set. */ + AIOF_NO_LOAD = 1 << 7, + + /** Service the vehicle when needed, otherwise skip this order; only for depots. */ + AIOF_SERVICE_IF_NEEDED = 1 << 2, + + /** All flags related to non-stop settings. */ + AIOF_NON_STOP_FLAGS = AIOF_NON_STOP_INTERMEDIATE | AIOF_NON_STOP_DESTINATION, + /** All flags related to unloading. */ + AIOF_UNLOAD_FLAGS = AIOF_TRANSFER | AIOF_UNLOAD | AIOF_NO_UNLOAD, + /** All flags related to loading. */ + AIOF_LOAD_FLAGS = AIOF_FULL_LOAD | AIOF_FULL_LOAD_ANY | AIOF_NO_LOAD, + + /** For marking invalid order flags */ + AIOF_INVALID = 0xFFFF, + }; + + /** Different constants related to the OrderPosition */ + enum OrderPosition { + CURRENT_ORDER = 0xFF, //!< Constant that gets resolved to the current order. + INVALID_ORDER = -1, //!< An invalid order. + }; + + /** + * Checks whether the given order id is valid for the given vehicle. + * @param vehicle_id The vehicle to check the order index for. + * @param order_position The order index to check. + * @pre AIVehicle::IsValidVehicle(vehicle_id). + * @return True if and only if the order_position is valid for the given vehicle. + */ + static bool IsValidVehicleOrder(VehicleID vehicle_id, OrderPosition order_position); + + /** + * Resolves the given order index to the correct index for the given vehicle. + * If the order index was CURRENT_ORDER it will be resolved to the index of + * the current order (as shown in the order list). If the order with the + * given index does not exist it will return INVALID_ORDER. + * @param vehicle_id The vehicle to check the order index for. + * @param order_position The order index to resolve. + * @pre AIVehicle::IsValidVehicle(vehicle_id). + * @return The resolved order index. + */ + static OrderPosition ResolveOrderPosition(VehicleID vehicle_id, OrderPosition order_position); + + /** + * Checks whether the given order flags are valid for the given destination. + * @param destination The destination of the order. + * @param order_flags The flags given to the order. + * @return True if and only if the order_flags are valid for the given location. + */ + static bool AreOrderFlagsValid(TileIndex destination, AIOrderFlags order_flags); + + /** + * Returns the number of orders for the given vehicle. + * @param vehicle_id The vehicle to get the order count of. + * @pre AIVehicle::IsValidVehicle(vehicle_id). + * @return The number of orders for the given vehicle or a negative + * value when the vehicle does not exist. + */ + static int32 GetOrderCount(VehicleID vehicle_id); + + /** + * Gets the destination of the given order for the given vehicle. + * @param vehicle_id The vehicle to get the destination for. + * @param order_position The order to get the destination for. + * @pre IsValidVehicleOrder(vehicle_id, order_position). + * @note Giving CURRENT_ORDER as order_position will give the order that is + * currently being executed by the vehicle. This is not necessarily the + * current order as given by ResolveOrderPosition (the current index in the + * order list) as manual or autoservicing depot orders do not show up + * in the orderlist, but they can be the current order of a vehicle. + * @return The destination tile of the order. + */ + static TileIndex GetOrderDestination(VehicleID vehicle_id, OrderPosition order_position); + + /** + * Gets the AIOrderFlags of the given order for the given vehicle. + * @param vehicle_id The vehicle to get the destination for. + * @param order_position The order to get the destination for. + * @pre IsValidVehicleOrder(vehicle_id, order_position). + * @note Giving CURRENT_ORDER as order_position will give the order that is + * currently being executed by the vehicle. This is not necessarily the + * current order as given by ResolveOrderPosition (the current index in the + * order list) as manual or autoservicing depot orders do not show up + * in the orderlist, but they can be the current order of a vehicle. + * @return The AIOrderFlags of the order. + */ + static AIOrderFlags GetOrderFlags(VehicleID vehicle_id, OrderPosition order_position); + + /** + * Appends an order to the end of the vehicle's order list. + * @param vehicle_id The vehicle to append the order to. + * @param destination The destination of the order. + * @param order_flags The flags given to the order. + * @pre AIVehicle::IsValidVehicle(vehicle_id). + * @pre AreOrderFlagsValid(destination, order_flags). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIOrder::ERR_ORDER_NO_MORE_SPACE + * @exception AIOrder::ERR_ORDER_TOO_FAR_AWAY_FROM_PREVIOUS_DESTINATION + * @return True if and only if the order was appended. + */ + static bool AppendOrder(VehicleID vehicle_id, TileIndex destination, AIOrderFlags order_flags); + + /** + * Inserts an order before the given order_position into the vehicle's order list. + * @param vehicle_id The vehicle to add the order to. + * @param order_position The order to place the new order before. + * @param destination The destination of the order. + * @param order_flags The flags given to the order. + * @pre IsValidVehicleOrder(vehicle_id, order_position). + * @pre AreOrderFlagsValid(destination, order_flags). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIOrder::ERR_ORDER_NO_MORE_SPACE + * @exception AIOrder::ERR_ORDER_TOO_FAR_AWAY_FROM_PREVIOUS_DESTINATION + * @return True if and only if the order was inserted. + */ + static bool InsertOrder(VehicleID vehicle_id, OrderPosition order_position, TileIndex destination, AIOrderFlags order_flags); + + /** + * Removes an order from the vehicle's order list. + * @param vehicle_id The vehicle to remove the order from. + * @param order_position The order to remove from the order list. + * @pre AIVehicle::IsValidVehicleOrder(vehicle_id, order_position). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return True if and only if the order was removed. + */ + static bool RemoveOrder(VehicleID vehicle_id, OrderPosition order_position); + +#ifndef DOXYGEN_SKIP + /** + * Internal function to help ChangeOrder. + */ + static bool _ChangeOrder(); +#endif + + /** + * Changes the order flags of the given order. + * @param vehicle_id The vehicle to change the order of. + * @param order_position The order to change. + * @param order_flags The new flags given to the order. + * @pre IsValidVehicleOrder(vehicle_id, order_position). + * @pre AreOrderFlagsValid(GetOrderDestination(vehicle_id, order_position), order_flags). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return True if and only if the order was changed. + */ + static bool ChangeOrder(VehicleID vehicle_id, OrderPosition order_position, AIOrderFlags order_flags); + + /** + * Move an order inside the orderlist + * @param vehicle_id The vehicle to move the orders. + * @param order_position_move The order to move. + * @param order_position_target The target order + * @pre IsValidVehicleOrder(vehicle_id, order_position_move). + * @pre IsValidVehicleOrder(vehicle_id, order_position_target). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return True if and only if the order was moved. + * @note If the order is moved to a lower place (e.g. from 7 to 2) + * the target order is moved upwards (e.g. 3). If the order is moved + * to a higher place (e.g. from 7 to 9) the target will be moved + * downwards (e.g. 8). + */ + static bool MoveOrder(VehicleID vehicle_id, OrderPosition order_position_move, OrderPosition order_position_target); + + /** + * Copies the orders from another vehicle. The orders of the main vehicle + * are going to be the orders of the changed vehicle. + * @param vehicle_id The vehicle to copy the orders to. + * @param main_vehicle_id The vehicle to copy the orders from. + * @pre AIVehicle::IsValidVehicle(vehicle_id). + * @pre AIVehicle::IsValidVehicle(main_vehicle_id). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIOrder::ERR_ORDER_NO_MORE_SPACE + * @return True if and only if the copying succeeded. + */ + static bool CopyOrders(VehicleID vehicle_id, VehicleID main_vehicle_id); + + /** + * Shares the orders between two vehicles. The orders of the main + * vehicle are going to be the orders of the changed vehicle. + * @param vehicle_id The vehicle to add to the shared order list. + * @param main_vehicle_id The vehicle to share the orders with. + * @pre AIVehicle::IsValidVehicle(vehicle_id). + * @pre AIVehicle::IsValidVehicle(main_vehicle_id). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return True if and only if the sharing succeeded. + */ + static bool ShareOrders(VehicleID vehicle_id, VehicleID main_vehicle_id); + + /** + * Removes the given vehicle from a shared orders list. + * @param vehicle_id The vehicle to remove from the shared order list. + * @pre AIVehicle::IsValidVehicle(vehicle_id). + * @return True if and only if the unsharing succeeded. + */ + static bool UnshareOrders(VehicleID vehicle_id); +}; +DECLARE_ENUM_AS_BIT_SET(AIOrder::AIOrderFlags); + +#endif /* AI_ORDER_HPP */ diff --git a/src/ai/api/ai_order.hpp.sq b/src/ai/api/ai_order.hpp.sq new file mode 100644 index 000000000..4128ae029 --- /dev/null +++ b/src/ai/api/ai_order.hpp.sq @@ -0,0 +1,71 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_order.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIOrder::ErrorMessages GetParam(ForceType<AIOrder::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIOrder::ErrorMessages)tmp; } + template <> int Return<AIOrder::ErrorMessages>(HSQUIRRELVM vm, AIOrder::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIOrder::AIOrderFlags GetParam(ForceType<AIOrder::AIOrderFlags>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIOrder::AIOrderFlags)tmp; } + template <> int Return<AIOrder::AIOrderFlags>(HSQUIRRELVM vm, AIOrder::AIOrderFlags res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIOrder::OrderPosition GetParam(ForceType<AIOrder::OrderPosition>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIOrder::OrderPosition)tmp; } + template <> int Return<AIOrder::OrderPosition>(HSQUIRRELVM vm, AIOrder::OrderPosition res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIOrder to be used as Squirrel parameter */ + template <> AIOrder *GetParam(ForceType<AIOrder *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIOrder *)instance; } + template <> AIOrder &GetParam(ForceType<AIOrder &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIOrder *)instance; } + template <> const AIOrder *GetParam(ForceType<const AIOrder *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIOrder *)instance; } + template <> const AIOrder &GetParam(ForceType<const AIOrder &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIOrder *)instance; } + template <> int Return<AIOrder *>(HSQUIRRELVM vm, AIOrder *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIOrder", res, NULL, DefSQDestructorCallback<AIOrder>); return 1; } +}; // namespace SQConvert + +void SQAIOrder_Register(Squirrel *engine) { + DefSQClass <AIOrder> SQAIOrder("AIOrder"); + SQAIOrder.PreRegister(engine); + SQAIOrder.AddConstructor<void (AIOrder::*)(), 1>(engine, "x"); + + SQAIOrder.DefSQConst(engine, AIOrder::ERR_ORDER_BASE, "ERR_ORDER_BASE"); + SQAIOrder.DefSQConst(engine, AIOrder::ERR_ORDER_TOO_MANY, "ERR_ORDER_TOO_MANY"); + SQAIOrder.DefSQConst(engine, AIOrder::ERR_ORDER_TOO_FAR_AWAY_FROM_PREVIOUS_DESTINATION, "ERR_ORDER_TOO_FAR_AWAY_FROM_PREVIOUS_DESTINATION"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_NONE, "AIOF_NONE"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_NON_STOP_INTERMEDIATE, "AIOF_NON_STOP_INTERMEDIATE"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_NON_STOP_DESTINATION, "AIOF_NON_STOP_DESTINATION"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_UNLOAD, "AIOF_UNLOAD"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_TRANSFER, "AIOF_TRANSFER"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_NO_UNLOAD, "AIOF_NO_UNLOAD"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_FULL_LOAD, "AIOF_FULL_LOAD"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_FULL_LOAD_ANY, "AIOF_FULL_LOAD_ANY"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_NO_LOAD, "AIOF_NO_LOAD"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_SERVICE_IF_NEEDED, "AIOF_SERVICE_IF_NEEDED"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_NON_STOP_FLAGS, "AIOF_NON_STOP_FLAGS"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_UNLOAD_FLAGS, "AIOF_UNLOAD_FLAGS"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_LOAD_FLAGS, "AIOF_LOAD_FLAGS"); + SQAIOrder.DefSQConst(engine, AIOrder::AIOF_INVALID, "AIOF_INVALID"); + SQAIOrder.DefSQConst(engine, AIOrder::CURRENT_ORDER, "CURRENT_ORDER"); + SQAIOrder.DefSQConst(engine, AIOrder::INVALID_ORDER, "INVALID_ORDER"); + + AIError::RegisterErrorMap(STR_8831_NO_MORE_SPACE_FOR_ORDERS, AIOrder::ERR_ORDER_TOO_MANY); + AIError::RegisterErrorMap(STR_0210_TOO_FAR_FROM_PREVIOUS_DESTINATIO, AIOrder::ERR_ORDER_TOO_FAR_AWAY_FROM_PREVIOUS_DESTINATION); + + AIError::RegisterErrorMapString(AIOrder::ERR_ORDER_TOO_MANY, "ERR_ORDER_TOO_MANY"); + AIError::RegisterErrorMapString(AIOrder::ERR_ORDER_TOO_FAR_AWAY_FROM_PREVIOUS_DESTINATION, "ERR_ORDER_TOO_FAR_AWAY_FROM_PREVIOUS_DESTINATION"); + + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::GetClassName, "GetClassName", 1, "x"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::IsValidVehicleOrder, "IsValidVehicleOrder", 3, "xii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::ResolveOrderPosition, "ResolveOrderPosition", 3, "xii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::AreOrderFlagsValid, "AreOrderFlagsValid", 3, "xii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::GetOrderCount, "GetOrderCount", 2, "xi"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::GetOrderDestination, "GetOrderDestination", 3, "xii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::GetOrderFlags, "GetOrderFlags", 3, "xii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::AppendOrder, "AppendOrder", 4, "xiii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::InsertOrder, "InsertOrder", 5, "xiiii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::RemoveOrder, "RemoveOrder", 3, "xii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::ChangeOrder, "ChangeOrder", 4, "xiii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::MoveOrder, "MoveOrder", 4, "xiii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::CopyOrders, "CopyOrders", 3, "xii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::ShareOrders, "ShareOrders", 3, "xii"); + SQAIOrder.DefSQStaticMethod(engine, &AIOrder::UnshareOrders, "UnshareOrders", 2, "xi"); + + SQAIOrder.PostRegister(engine); +} diff --git a/src/ai/api/ai_rail.cpp b/src/ai/api/ai_rail.cpp new file mode 100644 index 000000000..f35f98de3 --- /dev/null +++ b/src/ai/api/ai_rail.cpp @@ -0,0 +1,442 @@ +/* $Id$ */ + +/** @file ai_rail.cpp Implementation of AIRail. */ + +#include "ai_rail.hpp" +#include "ai_object.hpp" +#include "ai_map.hpp" +#include "../../openttd.h" +#include "../../debug.h" +#include "../../rail_map.h" +#include "../../road_map.h" +#include "../../command_type.h" +#include "../../station_map.h" +#include "../../company_func.h" +#include "../../core/math_func.hpp" +#include "../../waypoint.h" +#include "../../newgrf.h" +#include "../../newgrf_generic.h" +#include "../../newgrf_station.h" +#include "../../newgrf_callbacks.h" + +/* static */ bool AIRail::IsRailTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return (::IsTileType(tile, MP_RAILWAY) && !::IsRailDepot(tile)) || + (::IsRailwayStationTile(tile) && !::IsStationTileBlocked(tile)) || ::IsLevelCrossingTile(tile); +} + +/* static */ bool AIRail::IsLevelCrossingTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsLevelCrossingTile(tile); +} + +/* static */ bool AIRail::IsRailDepotTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsRailDepotTile(tile); +} + +/* static */ bool AIRail::IsRailStationTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsRailwayStationTile(tile); +} + +/* static */ bool AIRail::IsRailWaypointTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_RAILWAY) && ::IsRailWaypointTile(tile); +} + +/* static */ bool AIRail::IsRailTypeAvailable(RailType rail_type) +{ + if ((::RailType)rail_type < RAILTYPE_BEGIN || (::RailType)rail_type >= RAILTYPE_END) return false; + + return ::HasRailtypeAvail(_current_company, (::RailType)rail_type); +} + +/* static */ AIRail::RailType AIRail::GetCurrentRailType() +{ + return (RailType)AIObject::GetRailType(); +} + +/* static */ void AIRail::SetCurrentRailType(RailType rail_type) +{ + if (!IsRailTypeAvailable(rail_type)) return; + + AIObject::SetRailType((::RailType)rail_type); +} + +/* static */ bool AIRail::TrainCanRunOnRail(AIRail::RailType engine_rail_type, AIRail::RailType track_rail_type) +{ + if (!AIRail::IsRailTypeAvailable(engine_rail_type)) return false; + if (!AIRail::IsRailTypeAvailable(track_rail_type)) return false; + + return ::IsCompatibleRail((::RailType)engine_rail_type, (::RailType)track_rail_type); +} + +/* static */ bool AIRail::TrainHasPowerOnRail(AIRail::RailType engine_rail_type, AIRail::RailType track_rail_type) +{\ + if (!AIRail::IsRailTypeAvailable(engine_rail_type)) return false; + if (!AIRail::IsRailTypeAvailable(track_rail_type)) return false; + + return ::HasPowerOnRail((::RailType)engine_rail_type, (::RailType)track_rail_type); +} + +/* static */ AIRail::RailType AIRail::GetRailType(TileIndex tile) +{ + if (!AITile::HasTransportType(tile, AITile::TRANSPORT_RAIL)) return RAILTYPE_INVALID; + + return (RailType)::GetRailType(tile); +} + +/* static */ bool AIRail::ConvertRailType(TileIndex start_tile, TileIndex end_tile, AIRail::RailType convert_to) +{ + EnforcePrecondition(false, ::IsValidTile(start_tile)); + EnforcePrecondition(false, ::IsValidTile(end_tile)); + EnforcePrecondition(false, IsRailTypeAvailable(convert_to)); + + return AIObject::DoCommand(start_tile, end_tile, convert_to, CMD_CONVERT_RAIL); +} + +/* static */ TileIndex AIRail::GetRailDepotFrontTile(TileIndex depot) +{ + if (!IsRailDepotTile(depot)) return INVALID_TILE; + + return depot + ::TileOffsByDiagDir(::GetRailDepotDirection(depot)); +} + +/* static */ AIRail::RailTrack AIRail::GetRailStationDirection(TileIndex tile) +{ + if (!IsRailStationTile(tile)) return RAILTRACK_INVALID; + + return (RailTrack)::GetRailStationTrack(tile); +} + +/* static */ bool AIRail::BuildRailDepot(TileIndex tile, TileIndex front) +{ + EnforcePrecondition(false, tile != front); + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, ::IsValidTile(front)); + EnforcePrecondition(false, ::TileX(tile) == ::TileX(front) || ::TileY(tile) == ::TileY(front)); + EnforcePrecondition(false, IsRailTypeAvailable(GetCurrentRailType())); + + uint entrance_dir = (::TileX(tile) == ::TileX(front)) ? (::TileY(tile) < ::TileY(front) ? 1 : 3) : (::TileX(tile) < ::TileX(front) ? 2 : 0); + + return AIObject::DoCommand(tile, AIObject::GetRailType(), entrance_dir, CMD_BUILD_TRAIN_DEPOT); +} + +/* static */ bool AIRail::BuildRailStation(TileIndex tile, RailTrack direction, uint num_platforms, uint platform_length, bool join_adjacent) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, direction == RAILTRACK_NW_SE || direction == RAILTRACK_NE_SW); + EnforcePrecondition(false, num_platforms > 0 && num_platforms <= 0xFF); + EnforcePrecondition(false, platform_length > 0 && platform_length <= 0xFF); + EnforcePrecondition(false, IsRailTypeAvailable(GetCurrentRailType())); + + uint32 p1 = GetCurrentRailType() | (platform_length << 16) | (num_platforms << 8); + if (direction == RAILTRACK_NW_SE) p1 |= (1 << 4); + if (!join_adjacent) p1 |= (1 << 24); + return AIObject::DoCommand(tile, p1, INVALID_STATION << 16, CMD_BUILD_RAILROAD_STATION); +} + +/* static */ bool AIRail::BuildNewGRFRailStation(TileIndex tile, RailTrack direction, uint num_platforms, uint platform_length, bool join_adjacent, CargoID cargo_id, IndustryType source_industry, IndustryType goal_industry, int distance, bool source_station) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, direction == RAILTRACK_NW_SE || direction == RAILTRACK_NE_SW); + EnforcePrecondition(false, num_platforms > 0 && num_platforms <= 0xFF); + EnforcePrecondition(false, platform_length > 0 && platform_length <= 0xFF); + EnforcePrecondition(false, IsRailTypeAvailable(GetCurrentRailType())); + + uint32 p1 = GetCurrentRailType() | (platform_length << 16) | (num_platforms << 8); + if (direction == RAILTRACK_NW_SE) p1 |= 1 << 4; + if (!join_adjacent) p1 |= (1 << 24); + + const GRFFile *file; + uint16 res = GetAiPurchaseCallbackResult(GSF_STATION, cargo_id, 0, source_industry, goal_industry, min(255, distance / 2), AICE_STATION_GET_STATION_ID, source_station ? 0 : 1, min(15, num_platforms) << 4 | min(15, platform_length), &file); + uint32 p2 = INVALID_STATION << 16; + if (res != CALLBACK_FAILED) { + extern StationClass _station_classes[STAT_CLASS_MAX]; + const StationSpec *spec = GetCustomStationSpecByGrf(file->grfid, res); + int index = -1; + for (uint j = 0; j < _station_classes[spec->sclass].stations; j++) { + if (spec == _station_classes[spec->sclass].spec[j]) { + index = j; + break; + } + } + if (index == -1) { + DEBUG(grf, 1, "%s returned an invalid station ID for 'AI construction/purchase selection (18)' callback", file->filename); + } else { + p2 |= spec->sclass | index << 8; + } + + } + return AIObject::DoCommand(tile, p1, p2, CMD_BUILD_RAILROAD_STATION); +} + +/* static */ bool AIRail::RemoveRailStationTileRect(TileIndex tile, TileIndex tile2) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, ::IsValidTile(tile2)); + + return AIObject::DoCommand(tile, tile2, 0, CMD_REMOVE_FROM_RAILROAD_STATION); +} + +/* static */ uint AIRail::GetRailTracks(TileIndex tile) +{ + if (!IsRailTile(tile)) return RAILTRACK_INVALID; + + if (IsRailWaypointTile(tile)) return ::GetRailWaypointBits(tile); + if (IsRailStationTile(tile)) return ::TrackToTrackBits(::GetRailStationTrack(tile)); + if (IsLevelCrossingTile(tile)) return ::GetCrossingRailBits(tile); + return ::GetTrackBits(tile); +} + +/* static */ bool AIRail::BuildRailTrack(TileIndex tile, RailTrack rail_track) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, rail_track != 0); + EnforcePrecondition(false, (rail_track & ~::TRACK_BIT_ALL) == 0); + EnforcePrecondition(false, KillFirstBit((uint)rail_track) == 0); + EnforcePrecondition(false, IsRailTypeAvailable(GetCurrentRailType())); + + return AIObject::DoCommand(tile, tile, GetCurrentRailType() | (FindFirstTrack((::TrackBits)rail_track) << 4), CMD_BUILD_RAILROAD_TRACK); +} + +/* static */ bool AIRail::RemoveRailTrack(TileIndex tile, RailTrack rail_track) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, ::IsTileType(tile, MP_RAILWAY) && ::IsPlainRailTile(tile)); + EnforcePrecondition(false, GetRailTracks(tile) & rail_track); + EnforcePrecondition(false, KillFirstBit((uint)rail_track) == 0); + + return AIObject::DoCommand(tile, tile, GetCurrentRailType() | (FindFirstTrack((::TrackBits)rail_track) << 4), CMD_REMOVE_RAILROAD_TRACK); +} + +/* static */ bool AIRail::AreTilesConnected(TileIndex from, TileIndex tile, TileIndex to) +{ + if (!IsRailTile(tile)) return false; + if (from == to || AIMap::DistanceManhattan(from, tile) != 1 || AIMap::DistanceManhattan(tile, to) != 1) return false; + + if (to < from) ::Swap(from, to); + + if (tile - from == 1) { + if (to - tile == 1) return (GetRailTracks(tile) & RAILTRACK_NE_SW) != 0; + if (to - tile == ::MapSizeX()) return (GetRailTracks(tile) & RAILTRACK_NE_SE) != 0; + } else if (tile - from == ::MapSizeX()) { + if (tile - to == 1) return (GetRailTracks(tile) & RAILTRACK_NW_NE) != 0; + if (to - tile == 1) return (GetRailTracks(tile) & RAILTRACK_NW_SW) != 0; + if (to - tile == ::MapSizeX()) return (GetRailTracks(tile) & RAILTRACK_NW_SE) != 0; + } else { + return (GetRailTracks(tile) & RAILTRACK_SW_SE) != 0; + } + + NOT_REACHED(); +} + +/** + * Prepare the second parameter for CmdBuildRailroadTrack and CmdRemoveRailroadTrack. The direction + * depends on all three tiles. Sometimes the third tile needs to be adjusted. + */ +static uint32 SimulateDrag(TileIndex from, TileIndex tile, TileIndex *to) +{ + int diag_offset = abs(abs((int)::TileX(*to) - (int)::TileX(tile)) - abs((int)::TileY(*to) - (int)::TileY(tile))); + uint32 p2 = AIRail::GetCurrentRailType(); + if (::TileY(from) == ::TileY(*to)) { + p2 |= (TRACK_X << 4); + *to -= Clamp((int)::TileX(*to) - (int)::TileX(tile), -1, 1); + } else if (::TileX(from) == ::TileX(*to)) { + p2 |= (TRACK_Y << 4); + *to -= ::MapSizeX() * Clamp((int)::TileY(*to) - (int)::TileY(tile), -1, 1); + } else if (::TileY(from) < ::TileY(tile)) { + if (::TileX(*to) < ::TileX(tile)) { + p2 |= (TRACK_UPPER << 4); + } else { + p2 |= (TRACK_LEFT << 4); + } + if (diag_offset) { + *to -= Clamp((int)::TileX(*to) - (int)::TileX(tile), -1, 1); + } else { + *to -= ::MapSizeX() * Clamp((int)::TileY(*to) - (int)::TileY(tile), -1, 1); + } + } else if (::TileY(from) > ::TileY(tile)) { + if (::TileX(*to) < ::TileX(tile)) { + p2 |= (TRACK_RIGHT << 4); + } else { + p2 |= (TRACK_LOWER << 4); + } + if (diag_offset) { + *to -= Clamp((int)::TileX(*to) - (int)::TileX(tile), -1, 1); + } else { + *to -= ::MapSizeX() * Clamp((int)::TileY(*to) - (int)::TileY(tile), -1, 1); + } + } else if (::TileX(from) < ::TileX(tile)) { + if (::TileY(*to) < ::TileY(tile)) { + p2 |= (TRACK_UPPER << 4); + } else { + p2 |= (TRACK_RIGHT << 4); + } + if (!diag_offset) { + *to -= Clamp((int)::TileX(*to) - (int)::TileX(tile), -1, 1); + } else { + *to -= ::MapSizeX() * Clamp((int)::TileY(*to) - (int)::TileY(tile), -1, 1); + } + } else if (::TileX(from) > ::TileX(tile)) { + if (::TileY(*to) < ::TileY(tile)) { + p2 |= (TRACK_LEFT << 4); + } else { + p2 |= (TRACK_LOWER << 4); + } + if (!diag_offset) { + *to -= Clamp((int)::TileX(*to) - (int)::TileX(tile), -1, 1); + } else { + *to -= ::MapSizeX() * Clamp((int)::TileY(*to) - (int)::TileY(tile), -1, 1); + } + } + return p2; +} + +/* static */ bool AIRail::BuildRail(TileIndex from, TileIndex tile, TileIndex to) +{ + EnforcePrecondition(false, ::IsValidTile(from)); + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, ::IsValidTile(to)); + EnforcePrecondition(false, ::DistanceManhattan(from, tile) == 1); + EnforcePrecondition(false, ::DistanceManhattan(tile,to) >= 1); + EnforcePrecondition(false, IsRailTypeAvailable(GetCurrentRailType())); + int diag_offset = abs(abs((int)::TileX(to) - (int)::TileX(tile)) - abs((int)::TileY(to) - (int)::TileY(tile))); + EnforcePrecondition(false, diag_offset <= 1 || + (::TileX(from) == ::TileX(tile) && ::TileX(tile) == ::TileX(to)) || + (::TileY(from) == ::TileY(tile) && ::TileY(tile) == ::TileY(to))); + + uint32 p2 = SimulateDrag(from, tile, &to); + return AIObject::DoCommand(tile, to, p2, CMD_BUILD_RAILROAD_TRACK); +} + +/* static */ bool AIRail::RemoveRail(TileIndex from, TileIndex tile, TileIndex to) +{ + EnforcePrecondition(false, ::IsValidTile(from)); + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, ::IsValidTile(to)); + EnforcePrecondition(false, ::DistanceManhattan(from, tile) == 1); + EnforcePrecondition(false, ::DistanceManhattan(tile,to) >= 1); + int diag_offset = abs(abs((int)::TileX(to) - (int)::TileX(tile)) - abs((int)::TileY(to) - (int)::TileY(tile))); + EnforcePrecondition(false, diag_offset <= 1 || + (::TileX(from) == ::TileX(tile) && ::TileX(tile) == ::TileX(to)) || + (::TileY(from) == ::TileY(tile) && ::TileY(tile) == ::TileY(to))); + + if (!IsRailTypeAvailable(GetCurrentRailType())) SetCurrentRailType(GetRailType(tile)); + uint32 p2 = SimulateDrag(from, tile, &to); + return AIObject::DoCommand(tile, to, p2, CMD_REMOVE_RAILROAD_TRACK); +} + +/** + * Contains information about the trackdir that belongs to a track when entering + * from a specific direction. + */ +struct AIRailSignalData { + Track track; //!< The track that will be taken to travel. + Trackdir trackdir; //!< The Trackdir belonging to that track. + uint signal_cycles; //!< How many times the signal should be cycled in order to build it in the correct direction. +}; + +static const int NUM_TRACK_DIRECTIONS = 3; //!< The number of directions you can go when entering a tile. + +/** + * List information about the trackdir and number of needed cycles for building signals when + * entering a track from a specific direction. The first index is the difference between the + * TileIndex of the previous and current tile, where (-)MapSizeX is replaced with -2 / 2 and + * 2 it added. + */ +static const AIRailSignalData _possible_trackdirs[5][NUM_TRACK_DIRECTIONS] = { + {{TRACK_UPPER, TRACKDIR_UPPER_E, 0}, {TRACK_Y, TRACKDIR_Y_SE, 0}, {TRACK_LEFT, TRACKDIR_LEFT_S, 1}}, + {{TRACK_RIGHT, TRACKDIR_RIGHT_S, 1}, {TRACK_X, TRACKDIR_X_SW, 1}, {TRACK_UPPER, TRACKDIR_UPPER_W, 1}}, + {{INVALID_TRACK, INVALID_TRACKDIR, 0}, {INVALID_TRACK, INVALID_TRACKDIR, 0}, {INVALID_TRACK, INVALID_TRACKDIR, 0}}, + {{TRACK_LOWER, TRACKDIR_LOWER_E, 0}, {TRACK_X, TRACKDIR_X_NE, 0}, {TRACK_LEFT, TRACKDIR_LEFT_N, 0}}, + {{TRACK_RIGHT, TRACKDIR_RIGHT_N, 0}, {TRACK_Y, TRACKDIR_Y_NW, 1}, {TRACK_LOWER, TRACKDIR_LOWER_W, 1}} +}; + +/* static */ AIRail::SignalType AIRail::GetSignalType(TileIndex tile, TileIndex front) +{ + if (AIMap::DistanceManhattan(tile, front) != 1) return SIGNALTYPE_NONE; + if (!::IsTileType(tile, MP_RAILWAY) || !::HasSignals(tile)) return SIGNALTYPE_NONE; + + int data_index = 2 + (::TileX(front) - ::TileX(tile)) + 2 * (::TileY(front) - ::TileY(tile)); + + for (int i = 0; i < NUM_TRACK_DIRECTIONS; i++) { + const Track &track = _possible_trackdirs[data_index][i].track; + if (!(::TrackToTrackBits(track) & GetRailTracks(tile))) continue; + if (!HasSignalOnTrack(tile, track)) continue; + if (!HasSignalOnTrackdir(tile, _possible_trackdirs[data_index][i].trackdir)) continue; + SignalType st = (SignalType)::GetSignalType(tile, track); + if (HasSignalOnTrackdir(tile, ::ReverseTrackdir(_possible_trackdirs[data_index][i].trackdir))) st = (SignalType)(st | SIGNALTYPE_TWOWAY); + return st; + } + + return SIGNALTYPE_NONE; +} + +/** + * Check if signal_type is a valid SignalType. + */ +static bool IsValidSignalType(int signal_type) +{ + if (signal_type < AIRail::SIGNALTYPE_NORMAL || signal_type > AIRail::SIGNALTYPE_COMBO_TWOWAY) return false; + if (signal_type > AIRail::SIGNALTYPE_PBS_ONEWAY && signal_type < AIRail::SIGNALTYPE_NORMAL_TWOWAY) return false; + return true; +} + +/* static */ bool AIRail::BuildSignal(TileIndex tile, TileIndex front, SignalType signal) +{ + EnforcePrecondition(false, AIMap::DistanceManhattan(tile, front) == 1) + EnforcePrecondition(false, ::IsTileType(tile, MP_RAILWAY) && ::IsPlainRailTile(tile)); + EnforcePrecondition(false, ::IsValidSignalType(signal)); + + Track track = INVALID_TRACK; + uint signal_cycles; + + int data_index = 2 + (::TileX(front) - ::TileX(tile)) + 2 * (::TileY(front) - ::TileY(tile)); + for (int i = 0; i < NUM_TRACK_DIRECTIONS; i++) { + const Track &t = _possible_trackdirs[data_index][i].track; + if (!(::TrackToTrackBits(t) & GetRailTracks(tile))) continue; + track = t; + signal_cycles = _possible_trackdirs[data_index][i].signal_cycles; + break; + } + EnforcePrecondition(false, track != INVALID_TRACK); + + uint p1 = track; + if (signal < SIGNALTYPE_TWOWAY) { + if (signal != SIGNALTYPE_PBS && signal != SIGNALTYPE_PBS_ONEWAY) signal_cycles++; + p1 |= (signal_cycles << 15); + } + p1 |= ((signal >= SIGNALTYPE_TWOWAY ? signal ^ SIGNALTYPE_TWOWAY : signal) << 5); + + return AIObject::DoCommand(tile, p1, 0, CMD_BUILD_SIGNALS); +} + +/* static */ bool AIRail::RemoveSignal(TileIndex tile, TileIndex front) +{ + EnforcePrecondition(false, AIMap::DistanceManhattan(tile, front) == 1) + EnforcePrecondition(false, GetSignalType(tile, front) != SIGNALTYPE_NONE); + + Track track = INVALID_TRACK; + int data_index = 2 + (::TileX(front) - ::TileX(tile)) + 2 * (::TileY(front) - ::TileY(tile)); + for (int i = 0; i < NUM_TRACK_DIRECTIONS; i++) { + const Track &t = _possible_trackdirs[data_index][i].track; + if (!(::TrackToTrackBits(t) & GetRailTracks(tile))) continue; + track = t; + break; + } + EnforcePrecondition(false, track != INVALID_TRACK); + + return AIObject::DoCommand(tile, track, 0, CMD_REMOVE_SIGNALS); +} diff --git a/src/ai/api/ai_rail.hpp b/src/ai/api/ai_rail.hpp new file mode 100644 index 000000000..5acb995ff --- /dev/null +++ b/src/ai/api/ai_rail.hpp @@ -0,0 +1,390 @@ +/* $Id$ */ + +/** @file ai_rail.hpp Everything to query and build rails. */ + +#ifndef AI_RAIL_HPP +#define AI_RAIL_HPP + +#include "ai_object.hpp" +#include "ai_error.hpp" +#include "ai_tile.hpp" + +/** + * Class that handles all rail related functions. + */ +class AIRail : public AIObject { +public: + static const char *GetClassName() { return "AIRail"; } + + /** + * All rail related error messages. + */ + enum ErrorMessages { + /** Base for rail building / maintaining errors */ + ERR_RAIL_BASE = AIError::ERR_CAT_RAIL << AIError::ERR_CAT_BIT_SIZE, + + /** One-way roads cannot have crossings */ + ERR_CROSSING_ON_ONEWAY_ROAD, // [STR_ERR_CROSSING_ON_ONEWAY_ROAD] + + /** Track not suitable for signals */ + ERR_UNSUITABLE_TRACK, // [STR_1005_NO_SUITABLE_RAILROAD_TRACK] + + /** Non-uniform stations is diabled */ + ERR_NONUNIFORM_STATIONS_DISABLED, // [STR_NONUNIFORM_STATIONS_DISALLOWED] + }; + + /** + * Types of rail known to the game. + */ + enum RailType { + /* Note: the values _are_ important as they represent an in-game value */ + RAILTYPE_INVALID = 0xFF, //!< Invalid RailType. + }; + + /** + * A bitmap with all possible rail tracks on a tile. + */ + enum RailTrack { + /* Note: the values _are_ important as they represent an in-game value */ + RAILTRACK_NE_SW = 1 << 0, //!< Track along the x-axis (north-east to south-west). + RAILTRACK_NW_SE = 1 << 1, //!< Track along the y-axis (north-west to south-east). + RAILTRACK_NW_NE = 1 << 2, //!< Track in the upper corner of the tile (north). + RAILTRACK_SW_SE = 1 << 3, //!< Track in the lower corner of the tile (south). + RAILTRACK_NW_SW = 1 << 4, //!< Track in the left corner of the tile (west). + RAILTRACK_NE_SE = 1 << 5, //!< Track in the right corner of the tile (east). + RAILTRACK_INVALID = 0xFF, //!< Flag for an invalid track. + }; + + /** + * Types of signal known to the game. + */ + enum SignalType { + /* Note: the values _are_ important as they represent an in-game value */ + SIGNALTYPE_NORMAL = 0, //!< Normal signal. + SIGNALTYPE_ENTRY = 1, //!< Entry presignal. + SIGNALTYPE_EXIT = 2, //!< Exit signal. + SIGNALTYPE_COMBO = 3, //!< Combo signal. + SIGNALTYPE_PBS = 4, //!< Normal PBS signal. + SIGNALTYPE_PBS_ONEWAY = 5, //!< No-entry PBS signal. + SIGNALTYPE_TWOWAY = 8, //!< Bit mask for twoway signal. + SIGNALTYPE_NORMAL_TWOWAY = SIGNALTYPE_NORMAL | SIGNALTYPE_TWOWAY, //!< Normal twoway signal. + SIGNALTYPE_ENTRY_TWOWAY = SIGNALTYPE_ENTRY | SIGNALTYPE_TWOWAY, //!< Entry twoway signal. + SIGNALTYPE_EXIT_TWOWAY = SIGNALTYPE_EXIT | SIGNALTYPE_TWOWAY, //!< Exit twoway signal. + SIGNALTYPE_COMBO_TWOWAY = SIGNALTYPE_COMBO | SIGNALTYPE_TWOWAY, //!< Combo twoway signal. + SIGNALTYPE_NONE = 0xFF, //!< No signal. + }; + + /** + * Checks whether the given tile is actually a tile with rail that can be + * used to traverse a tile. This excludes rail depots but includes + * stations and waypoints. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has rail. + */ + static bool IsRailTile(TileIndex tile); + + /** + * Checks whether there is a road / rail crossing on a tile. + * @param tile The tile to check. + * @return True if and only if there is a road / rail crossing. + */ + static bool IsLevelCrossingTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a rail depot. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a rail depot. + */ + static bool IsRailDepotTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a rail station. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a rail station. + */ + static bool IsRailStationTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a rail waypoint. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a rail waypoint. + */ + static bool IsRailWaypointTile(TileIndex tile); + + /** + * Check if a given RailType is available. + * @param rail_type The RailType to check for. + * @return True if this RailType can be used. + */ + static bool IsRailTypeAvailable(RailType rail_type); + + /** + * Get the current RailType set for all AIRail functions. + * @return The RailType currently set. + */ + static RailType GetCurrentRailType(); + + /** + * Set the RailType for all further AIRail functions. + * @param rail_type The RailType to set. + */ + static void SetCurrentRailType(RailType rail_type); + + /** + * Check if a train build for a rail type can run on another rail type. + * @param engine_rail_type The rail type the train is build for. + * @param track_rail_type The type you want to check. + * @pre AIRail::IsRailTypeAvailable(engine_rail_type). + * @pre AIRail::IsRailTypeAvailable(track_rail_type). + * @return Whether a train build for 'engine_rail_type' can run on 'track_rail_type'. + * @note Even if a train can run on a RailType that doesn't mean that it'll be + * able to power the train. Use TrainHasPowerOnRail for that. + */ + static bool TrainCanRunOnRail(AIRail::RailType engine_rail_type, AIRail::RailType track_rail_type); + + /** + * Check if a train build for a rail type has power on another rail type. + * @param engine_rail_type The rail type the train is build for. + * @param track_rail_type The type you want to check. + * @pre AIRail::IsRailTypeAvailable(engine_rail_type). + * @pre AIRail::IsRailTypeAvailable(track_rail_type). + * @return Whether a train build for 'engine_rail_type' has power on 'track_rail_type'. + */ + static bool TrainHasPowerOnRail(AIRail::RailType engine_rail_type, AIRail::RailType track_rail_type); + + /** + * Get the RailType that is used on a tile. + * @param tile The tile to check. + * @pre AITile::HasTransportType(tile, AITile.TRANSPORT_RAIL). + * @return The RailType that is used on a tile. + */ + static RailType GetRailType(TileIndex tile); + + /** + * Convert the tracks on all tiles within a rectangle to another RailType. + * @param start_tile One corner of the rectangle. + * @param end_tile The opposite corner of the rectangle. + * @param convert_to The RailType you want to convert the rails to. + * @pre AIMap::IsValidTile(start_tile). + * @pre AIMap::IsValidTile(end_tile). + * @pre IsRailTypeAvailable(convert_to). + * @exception AIRail::ERR_UNSUITABLE_TRACK + * @return Whether at least some rail has been converted succesfully. + */ + static bool ConvertRailType(TileIndex start_tile, TileIndex end_tile, AIRail::RailType convert_to); + + /** + * Gets the tile in front of a rail depot. + * @param depot The rail depot tile. + * @pre IsRailDepotTile(depot). + * @return The tile in front of the depot. + */ + static TileIndex GetRailDepotFrontTile(TileIndex depot); + + /** + * Gets the direction of a rail station tile. + * @param tile The rail station tile. + * @pre IsRailStationTile(tile). + * @return The direction of the station (either RAILTRACK_NE_SW or RAILTRACK_NW_SE). + */ + static RailTrack GetRailStationDirection(TileIndex tile); + + /** + * Builds a rail depot. + * @param tile Place to build the depot. + * @param front The tile exactly in front of the depot. + * @pre AIMap::IsValidTile(tile). + * @pre AIMap::IsValidTile(front). + * @pre 'tile' is not equal to 'front', but in a straight line of it. + * @pre IsRailTypeAvailable(GetCurrentRailType()). + * @exception AIError::ERR_FLAT_LAND_REQUIRED + * @exception AIError::ERR_AREA_NOT_CLEAR + * @return Whether the rail depot has been/can be build or not. + */ + static bool BuildRailDepot(TileIndex tile, TileIndex front); + + /** + * Build a rail station. + * @param tile Place to build the station. + * @param direction The direction to build the station. + * @param num_platforms The number of platforms to build. + * @param platform_length The length of each platform. + * @param join_adjacent When building next to an other station, don't create a new station when this flag is true. + * @pre IsRailTypeAvailable(GetCurrentRailType()). + * @pre AIMap::IsValidTile(tile). + * @pre direction == RAILTRACK_NW_SE || direction == RAILTRACK_NE_SW. + * @pre num_platforms > 0 && num_platforms <= 255. + * @pre platform_length > 0 && platform_length <= 255. + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_FLAT_LAND_REQUIRED + * @exception AIStation::ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION + * @exception AIStation::ERR_STATION_TOO_MANY_STATIONS + * @exception AIStation::ERR_STATION_TOO_MANY_STATIONS_IN_TOWN + * @return Whether the station has been/can be build or not. + */ + static bool BuildRailStation(TileIndex tile, RailTrack direction, uint num_platforms, uint platform_length, bool join_adjacent); + + /** + * Build a NewGRF rail station. This calls callback 18 to let a NewGRF + * provide the station class / id to build, so we don't end up with + * only the default stations on the map. + * @param tile Place to build the station. + * @param direction The direction to build the station. + * @param num_platforms The number of platforms to build. + * @param platform_length The length of each platform. + * @param join_adjacent When building next to an other station, don't create a new station when this flag is true. + * @param cargo_id The CargoID of the cargo that will be transported from / to this station. + * @param source_industry The IndustryType of the industry you'll transport goods from. + * @param goal_industry The IndustryType of the industry you'll transport goods to. + * @param distance The manhattan distance you'll transport the cargo over. + * @param source_station True if this is the source station, false otherwise. + * @pre IsRailTypeAvailable(GetCurrentRailType()). + * @pre AIMap::IsValidTile(tile). + * @pre direction == RAILTRACK_NW_SE || direction == RAILTRACK_NE_SW. + * @pre num_platforms > 0 && num_platforms <= 255. + * @pre platform_length > 0 && platform_length <= 255. + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_FLAT_LAND_REQUIRED + * @exception AIStation::ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION + * @exception AIStation::ERR_STATION_TOO_MANY_STATIONS + * @exception AIStation::ERR_STATION_TOO_MANY_STATIONS_IN_TOWN + * @return Whether the station has been/can be build or not. + */ + static bool BuildNewGRFRailStation(TileIndex tile, RailTrack direction, uint num_platforms, uint platform_length, bool join_adjacent, CargoID cargo_id, IndustryType source_industry, IndustryType goal_industry, int distance, bool source_station); + + /** + * Remove a rectangle of platform pieces from a rail station. + * @param tile One corner of the rectangle to clear. + * @param tile2 The oppposite corner. + * @pre IsValidTile(tile). + * @pre IsValidTile(tile2). + * @return Whether at least one tile has been/can be cleared or not. + */ + static bool RemoveRailStationTileRect(TileIndex tile, TileIndex tile2); + + /** + * Get all RailTracks on the given tile. + * @param tile The tile to check. + * @pre IsRailTile(tile). + * @return A bitmask of RailTrack with all RailTracks on the tile. + */ + static uint GetRailTracks(TileIndex tile); + + /** + * Build rail on the given tile. + * @param tile The tile to build on. + * @param rail_track The RailTrack to build. + * @pre AIMap::IsValidTile(tile). + * @pre IsRailTypeAvailable(GetCurrentRailType()). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_LAND_SLOPED_WRONG + * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS + * @exception AIRail::ERR_CROSSING_ON_ONEWAY_ROAD + * @exception AIError::ERR_ALREADY_BUILT + * @return Whether the rail has been/can be build or not. + * @note You can only build a single track with this function so do not + * use the values from RailTrack as bitmask. + */ + static bool BuildRailTrack(TileIndex tile, RailTrack rail_track); + + /** + * Remove rail on the given tile. + * @param tile The tile to remove rail from. + * @param rail_track The RailTrack to remove. + * @pre AIMap::IsValidTile(tile). + * @pre (GetRailTracks(tile) & rail_track) != 0. + * @return Whether the rail has been/can be removed or not. + * @note You can only remove a single track with this function so do not + * use the values from RailTrack as bitmask. + */ + static bool RemoveRailTrack(TileIndex tile, RailTrack rail_track); + + /** + * Check if a tile connects two adjacent tiles. + * @param from The first tile to connect. + * @param tile The tile that is checked. + * @param to The second tile to connect. + * @pre from != to. + * @pre AIMap::DistanceManhattan(from, tile) == 1. + * @pre AIMap::DistanceManhattan(to, tile) == 1. + * @return True if 'tile' connects 'from' and 'to'. + */ + static bool AreTilesConnected(TileIndex from, TileIndex tile, TileIndex to); + + /** + * Build a rail connection between two tiles. + * @param from The tile just before the tile to build on. + * @param tile The first tile to build on. + * @param to The tile just after the last tile to build on. + * @pre from != to. + * @pre AIMap::DistanceManhattan(from, tile) == 1. + * @pre AIMap::DistanceManhattan(to, tile) >= 1. + * @pre (abs(abs(AIMap::GetTileX(to) - AIMap::GetTileX(tile)) - + * abs(AIMap::GetTileY(to) - AIMap::GetTileY(tile))) <= 1) || + * (AIMap::GetTileX(from) == AIMap::GetTileX(tile) && AIMap::GetTileX(tile) == AIMap::GetTileX(to)) || + * (AIMap::GetTileY(from) == AIMap::GetTileY(tile) && AIMap::GetTileY(tile) == AIMap::GetTileY(to)). + * @pre IsRailTypeAvailable(GetCurrentRailType()). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_LAND_SLOPED_WRONG + * @exception AIRail::ERR_CROSSING_ON_ONEWAY_ROAD + * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS + * @exception AIError::ERR_ALREADY_BUILT + * @return Whether the rail has been/can be build or not. + */ + static bool BuildRail(TileIndex from, TileIndex tile, TileIndex to); + + /** + * Remove a rail connection between two tiles. + * @param from The tile just before the tile to remove rail from. + * @param tile The first tile to remove rail from. + * @param to The tile just after the last tile to remove rail from. + * @pre from != to. + * @pre AIMap::DistanceManhattan(from, tile) == 1. + * @pre AIMap::DistanceManhattan(to, tile) >= 1. + * @pre (abs(abs(AIMap::GetTileX(to) - AIMap::GetTileX(tile)) - + * abs(AIMap::GetTileY(to) - AIMap::GetTileY(tile))) <= 1) || + * (AIMap::GetTileX(from) == AIMap::GetTileX(tile) && AIMap::GetTileX(tile) == AIMap::GetTileX(to)) || + * (AIMap::GetTileY(from) == AIMap::GetTileY(tile) && AIMap::GetTileY(tile) == AIMap::GetTileY(to)). + * @return Whether the rail has been/can be removed or not. + */ + static bool RemoveRail(TileIndex from, TileIndex tile, TileIndex to); + + /** + * Get the SignalType of the signal on a tile or SIGNALTYPE_NONE if there is no signal. + * @pre AIMap::DistanceManhattan(tile, front) == 1. + * @param tile The tile that might have a signal. + * @param front The tile in front of 'tile'. + * @return The SignalType of the signal on 'tile' with it's front to 'front'. + */ + static SignalType GetSignalType(TileIndex tile, TileIndex front); + + /** + * Build a signal on a tile. + * @param tile The tile to build on. + * @param front The tile in front of the signal. + * @param signal The SignalType to build. + * @pre AIMap::DistanceManhattan(tile, front) == 1. + * @pre IsRailTile(tile) && !IsRailStationTile(tile) && !IsRailWaypointTile(tile). + * @exception AIRail::ERR_UNSUITABLE_TRACK + * @return Whether the signal has been/can be build or not. + */ + static bool BuildSignal(TileIndex tile, TileIndex front, SignalType signal); + + /** + * Remove a signal. + * @param tile The tile to remove the signal from. + * @param front The tile in front of the signal. + * @pre AIMap::DistanceManhattan(tile, front) == 1. + * @pre GetSignalType(tile, front) != SIGNALTYPE_NONE. + * @return Whether the signal has been/can be removed or not. + */ + static bool RemoveSignal(TileIndex tile, TileIndex front); +}; + +#endif /* AI_RAIL_HPP */ diff --git a/src/ai/api/ai_rail.hpp.sq b/src/ai/api/ai_rail.hpp.sq new file mode 100644 index 000000000..a77d34c70 --- /dev/null +++ b/src/ai/api/ai_rail.hpp.sq @@ -0,0 +1,93 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_rail.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIRail::ErrorMessages GetParam(ForceType<AIRail::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIRail::ErrorMessages)tmp; } + template <> int Return<AIRail::ErrorMessages>(HSQUIRRELVM vm, AIRail::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIRail::RailType GetParam(ForceType<AIRail::RailType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIRail::RailType)tmp; } + template <> int Return<AIRail::RailType>(HSQUIRRELVM vm, AIRail::RailType res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIRail::RailTrack GetParam(ForceType<AIRail::RailTrack>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIRail::RailTrack)tmp; } + template <> int Return<AIRail::RailTrack>(HSQUIRRELVM vm, AIRail::RailTrack res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIRail::SignalType GetParam(ForceType<AIRail::SignalType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIRail::SignalType)tmp; } + template <> int Return<AIRail::SignalType>(HSQUIRRELVM vm, AIRail::SignalType res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIRail to be used as Squirrel parameter */ + template <> AIRail *GetParam(ForceType<AIRail *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIRail *)instance; } + template <> AIRail &GetParam(ForceType<AIRail &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIRail *)instance; } + template <> const AIRail *GetParam(ForceType<const AIRail *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIRail *)instance; } + template <> const AIRail &GetParam(ForceType<const AIRail &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIRail *)instance; } + template <> int Return<AIRail *>(HSQUIRRELVM vm, AIRail *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIRail", res, NULL, DefSQDestructorCallback<AIRail>); return 1; } +}; // namespace SQConvert + +void SQAIRail_Register(Squirrel *engine) { + DefSQClass <AIRail> SQAIRail("AIRail"); + SQAIRail.PreRegister(engine); + SQAIRail.AddConstructor<void (AIRail::*)(), 1>(engine, "x"); + + SQAIRail.DefSQConst(engine, AIRail::ERR_RAIL_BASE, "ERR_RAIL_BASE"); + SQAIRail.DefSQConst(engine, AIRail::ERR_CROSSING_ON_ONEWAY_ROAD, "ERR_CROSSING_ON_ONEWAY_ROAD"); + SQAIRail.DefSQConst(engine, AIRail::ERR_UNSUITABLE_TRACK, "ERR_UNSUITABLE_TRACK"); + SQAIRail.DefSQConst(engine, AIRail::ERR_NONUNIFORM_STATIONS_DISABLED, "ERR_NONUNIFORM_STATIONS_DISABLED"); + SQAIRail.DefSQConst(engine, AIRail::RAILTYPE_INVALID, "RAILTYPE_INVALID"); + SQAIRail.DefSQConst(engine, AIRail::RAILTRACK_NE_SW, "RAILTRACK_NE_SW"); + SQAIRail.DefSQConst(engine, AIRail::RAILTRACK_NW_SE, "RAILTRACK_NW_SE"); + SQAIRail.DefSQConst(engine, AIRail::RAILTRACK_NW_NE, "RAILTRACK_NW_NE"); + SQAIRail.DefSQConst(engine, AIRail::RAILTRACK_SW_SE, "RAILTRACK_SW_SE"); + SQAIRail.DefSQConst(engine, AIRail::RAILTRACK_NW_SW, "RAILTRACK_NW_SW"); + SQAIRail.DefSQConst(engine, AIRail::RAILTRACK_NE_SE, "RAILTRACK_NE_SE"); + SQAIRail.DefSQConst(engine, AIRail::RAILTRACK_INVALID, "RAILTRACK_INVALID"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_NORMAL, "SIGNALTYPE_NORMAL"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_ENTRY, "SIGNALTYPE_ENTRY"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_EXIT, "SIGNALTYPE_EXIT"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_COMBO, "SIGNALTYPE_COMBO"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_PBS, "SIGNALTYPE_PBS"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_PBS_ONEWAY, "SIGNALTYPE_PBS_ONEWAY"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_TWOWAY, "SIGNALTYPE_TWOWAY"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_NORMAL_TWOWAY, "SIGNALTYPE_NORMAL_TWOWAY"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_ENTRY_TWOWAY, "SIGNALTYPE_ENTRY_TWOWAY"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_EXIT_TWOWAY, "SIGNALTYPE_EXIT_TWOWAY"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_COMBO_TWOWAY, "SIGNALTYPE_COMBO_TWOWAY"); + SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_NONE, "SIGNALTYPE_NONE"); + + AIError::RegisterErrorMap(STR_ERR_CROSSING_ON_ONEWAY_ROAD, AIRail::ERR_CROSSING_ON_ONEWAY_ROAD); + AIError::RegisterErrorMap(STR_1005_NO_SUITABLE_RAILROAD_TRACK, AIRail::ERR_UNSUITABLE_TRACK); + AIError::RegisterErrorMap(STR_NONUNIFORM_STATIONS_DISALLOWED, AIRail::ERR_NONUNIFORM_STATIONS_DISABLED); + + AIError::RegisterErrorMapString(AIRail::ERR_CROSSING_ON_ONEWAY_ROAD, "ERR_CROSSING_ON_ONEWAY_ROAD"); + AIError::RegisterErrorMapString(AIRail::ERR_UNSUITABLE_TRACK, "ERR_UNSUITABLE_TRACK"); + AIError::RegisterErrorMapString(AIRail::ERR_NONUNIFORM_STATIONS_DISABLED, "ERR_NONUNIFORM_STATIONS_DISABLED"); + + SQAIRail.DefSQStaticMethod(engine, &AIRail::GetClassName, "GetClassName", 1, "x"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::IsRailTile, "IsRailTile", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::IsLevelCrossingTile, "IsLevelCrossingTile", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::IsRailDepotTile, "IsRailDepotTile", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::IsRailStationTile, "IsRailStationTile", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::IsRailWaypointTile, "IsRailWaypointTile", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::IsRailTypeAvailable, "IsRailTypeAvailable", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::GetCurrentRailType, "GetCurrentRailType", 1, "x"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::SetCurrentRailType, "SetCurrentRailType", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::TrainCanRunOnRail, "TrainCanRunOnRail", 3, "xii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::TrainHasPowerOnRail, "TrainHasPowerOnRail", 3, "xii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::GetRailType, "GetRailType", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::ConvertRailType, "ConvertRailType", 4, "xiii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::GetRailDepotFrontTile, "GetRailDepotFrontTile", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::GetRailStationDirection, "GetRailStationDirection", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::BuildRailDepot, "BuildRailDepot", 3, "xii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::BuildRailStation, "BuildRailStation", 6, "xiiiib"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::BuildNewGRFRailStation, "BuildNewGRFRailStation", 11, "xiiiibiiiib"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::RemoveRailStationTileRect, "RemoveRailStationTileRect", 3, "xii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::GetRailTracks, "GetRailTracks", 2, "xi"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::BuildRailTrack, "BuildRailTrack", 3, "xii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::RemoveRailTrack, "RemoveRailTrack", 3, "xii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::AreTilesConnected, "AreTilesConnected", 4, "xiii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::BuildRail, "BuildRail", 4, "xiii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::RemoveRail, "RemoveRail", 4, "xiii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::GetSignalType, "GetSignalType", 3, "xii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::BuildSignal, "BuildSignal", 4, "xiii"); + SQAIRail.DefSQStaticMethod(engine, &AIRail::RemoveSignal, "RemoveSignal", 3, "xii"); + + SQAIRail.PostRegister(engine); +} diff --git a/src/ai/api/ai_railtypelist.cpp b/src/ai/api/ai_railtypelist.cpp new file mode 100644 index 000000000..494cb5222 --- /dev/null +++ b/src/ai/api/ai_railtypelist.cpp @@ -0,0 +1,14 @@ +/* $Id$ */ + +/** @file ai_railtypelist.cpp Implementation of AIRailTypeList and friends. */ + +#include "ai_railtypelist.hpp" +#include "../../rail.h" +#include "../../company_func.h" + +AIRailTypeList::AIRailTypeList() +{ + for (RailType rt = RAILTYPE_BEGIN; rt != RAILTYPE_END; rt++) { + if (::HasRailtypeAvail(_current_company, rt)) this->AddItem(rt); + } +} diff --git a/src/ai/api/ai_railtypelist.hpp b/src/ai/api/ai_railtypelist.hpp new file mode 100644 index 000000000..f9837d7b6 --- /dev/null +++ b/src/ai/api/ai_railtypelist.hpp @@ -0,0 +1,20 @@ +/* $Id$ */ + +/** @file ai_railtypelist.hpp List all available railtypes. */ + +#ifndef AI_RAILTYPELIST_HPP +#define AI_RAILTYPELIST_HPP + +#include "ai_abstractlist.hpp" + +/** + * Creates a list of all available railtypes. + * @ingroup AIList + */ +class AIRailTypeList : public AIAbstractList { +public: + static const char *GetClassName() { return "AIRailTypeList"; } + AIRailTypeList(); +}; + +#endif /* AI_RAILTYPELIST_HPP */ diff --git a/src/ai/api/ai_railtypelist.hpp.sq b/src/ai/api/ai_railtypelist.hpp.sq new file mode 100644 index 000000000..255124bf6 --- /dev/null +++ b/src/ai/api/ai_railtypelist.hpp.sq @@ -0,0 +1,23 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_railtypelist.hpp" + +namespace SQConvert { + /* Allow AIRailTypeList to be used as Squirrel parameter */ + template <> AIRailTypeList *GetParam(ForceType<AIRailTypeList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIRailTypeList *)instance; } + template <> AIRailTypeList &GetParam(ForceType<AIRailTypeList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIRailTypeList *)instance; } + template <> const AIRailTypeList *GetParam(ForceType<const AIRailTypeList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIRailTypeList *)instance; } + template <> const AIRailTypeList &GetParam(ForceType<const AIRailTypeList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIRailTypeList *)instance; } + template <> int Return<AIRailTypeList *>(HSQUIRRELVM vm, AIRailTypeList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIRailTypeList", res, NULL, DefSQDestructorCallback<AIRailTypeList>); return 1; } +}; // namespace SQConvert + +void SQAIRailTypeList_Register(Squirrel *engine) { + DefSQClass <AIRailTypeList> SQAIRailTypeList("AIRailTypeList"); + SQAIRailTypeList.PreRegister(engine, "AIAbstractList"); + SQAIRailTypeList.AddConstructor<void (AIRailTypeList::*)(), 1>(engine, "x"); + + SQAIRailTypeList.DefSQStaticMethod(engine, &AIRailTypeList::GetClassName, "GetClassName", 1, "x"); + + SQAIRailTypeList.PostRegister(engine); +} diff --git a/src/ai/api/ai_road.cpp b/src/ai/api/ai_road.cpp new file mode 100644 index 000000000..a6a14656c --- /dev/null +++ b/src/ai/api/ai_road.cpp @@ -0,0 +1,548 @@ +/* $Id$ */ + +/** @file ai_road.cpp Implementation of AIRoad. */ + +#include "ai_road.hpp" +#include "ai_map.hpp" +#include "ai_list.hpp" +#include "../../openttd.h" +#include "../../road_map.h" +#include "../../station_map.h" +#include "../../tunnelbridge_map.h" +#include "../../command_type.h" +#include "../../company_func.h" +#include "../../settings_type.h" +#include "../../script/squirrel_helper_type.hpp" + +/* static */ bool AIRoad::IsRoadTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return (::IsTileType(tile, MP_ROAD) && ::GetRoadTileType(tile) != ROAD_TILE_DEPOT) || + IsDriveThroughRoadStationTile(tile); +} + +/* static */ bool AIRoad::IsRoadDepotTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_ROAD) && ::GetRoadTileType(tile) == ROAD_TILE_DEPOT && + (::RoadTypeToRoadTypes((::RoadType)GetCurrentRoadType()) & ::GetRoadTypes(tile)) != 0; +} + +/* static */ bool AIRoad::IsRoadStationTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsRoadStopTile(tile) && (::RoadTypeToRoadTypes((::RoadType)GetCurrentRoadType()) & ::GetRoadTypes(tile)) != 0; +} + +/* static */ bool AIRoad::IsDriveThroughRoadStationTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsDriveThroughStopTile(tile) && (::RoadTypeToRoadTypes((::RoadType)GetCurrentRoadType()) & ::GetRoadTypes(tile)) != 0; +} + +/* static */ bool AIRoad::IsRoadTypeAvailable(RoadType road_type) +{ + return ::HasRoadTypesAvail(_current_company, ::RoadTypeToRoadTypes((::RoadType)road_type)); +} + +/* static */ AIRoad::RoadType AIRoad::GetCurrentRoadType() +{ + return (RoadType)AIObject::GetRoadType(); +} + +/* static */ void AIRoad::SetCurrentRoadType(RoadType road_type) +{ + if (!IsRoadTypeAvailable(road_type)) return; + + AIObject::SetRoadType((::RoadType)road_type); +} + +/* static */ bool AIRoad::HasRoadType(TileIndex tile, RoadType road_type) +{ + if (!AIMap::IsValidTile(tile)) return false; + if (!IsRoadTypeAvailable(road_type)) return false; + return ::GetAnyRoadBits(tile, (::RoadType)road_type, false) != ROAD_NONE; +} + +/* static */ bool AIRoad::AreRoadTilesConnected(TileIndex t1, TileIndex t2) +{ + if (!::IsValidTile(t1)) return false; + if (!::IsValidTile(t2)) return false; + + /* Tiles not neighbouring */ + if ((abs((int)::TileX(t1) - (int)::TileX(t2)) + abs((int)::TileY(t1) - (int)::TileY(t2))) != 1) return false; + + RoadBits r1 = ::GetAnyRoadBits(t1, AIObject::GetRoadType()); + RoadBits r2 = ::GetAnyRoadBits(t2, AIObject::GetRoadType()); + + uint dir_1 = (::TileX(t1) == ::TileX(t2)) ? (::TileY(t1) < ::TileY(t2) ? 2 : 0) : (::TileX(t1) < ::TileX(t2) ? 1 : 3); + uint dir_2 = 2 ^ dir_1; + + DisallowedRoadDirections drd2 = IsNormalRoadTile(t2) ? GetDisallowedRoadDirections(t2) : DRD_NONE; + + return HasBit(r1, dir_1) && HasBit(r2, dir_2) && drd2 != DRD_BOTH && drd2 != (dir_1 > dir_2 ? DRD_SOUTHBOUND : DRD_NORTHBOUND); +} + +/* Helper functions for AIRoad::CanBuildConnectedRoadParts(). */ + +/** + * Check whether the given existing bits the start and end part can be build. + * As the function assumes the bits being build on a slope that does not + * allow level foundations all of the existing parts will always be in + * a straight line. This also needs to hold for the start and end parts, + * otherwise it is for sure not valid. Finally a check will be done to + * determine whether the existing road parts match the to-be-build parts. + * As they can only be placed in one direction, just checking the start + * part with the first existing part is enough. + * @param existing The existing road parts. + * @param start The part that should be build first. + * @param end The part that will be build second. + * @return True if and only if the road bits can be build. + */ +static bool CheckAutoExpandedRoadBits(const Array *existing, int32 start, int32 end) +{ + return (start + end == 0) && (existing->size == 0 || existing->array[0] == start || existing->array[0] == end); +} + +/** + * Lookup function for building road parts when building on slopes is disabled. + * @param slope The slope of the tile to examine. + * @param existing The existing road parts. + * @param start The part that should be build first. + * @param end The part that will be build second. + * @return 0 when the build parts do not connect, 1 when they do connect once + * they are build or 2 when building the first part automatically + * builds the second part. + */ +static int32 LookupWithoutBuildOnSlopes(::Slope slope, const Array *existing, int32 start, int32 end) +{ + switch (slope) { + /* Flat slopes can always be build. */ + case SLOPE_FLAT: + return 1; + + /* Only 4 of the slopes can be build upon. Testing the existing bits is + * necessary because these bits can be something else when the settings + * in the game have been changed. + */ + case SLOPE_NE: case SLOPE_SW: + return (CheckAutoExpandedRoadBits(existing, start, end) && (start == 1 || end == 1)) ? (existing->size == 0 ? 2 : 1) : 0; + case SLOPE_SE: case SLOPE_NW: + return (CheckAutoExpandedRoadBits(existing, start, end) && (start != 1 && end != 1)) ? (existing->size == 0 ? 2 : 1) : 0; + + /* Any other tile cannot be built on. */ + default: + return 0; + } +} + +/** + * Rotate a neighbour bit a single time clockwise. + * @param neighbour The neighbour. + * @return The rotate neighbour data. + */ +static int32 RotateNeighbour(int32 neighbour) +{ + switch (neighbour) { + case -2: return -1; + case -1: return 2; + case 1: return -2; + case 2: return 1; + default: NOT_REACHED(); + } +} + +/** + * Convert a neighbour to a road bit representation for easy internal use. + * @param neighbour The neighbour. + * @return The bits representing the direction. + */ +static RoadBits NeighbourToRoadBits(int32 neighbour) +{ + switch (neighbour) { + case -2: return ROAD_NW; + case -1: return ROAD_NE; + case 2: return ROAD_SE; + case 1: return ROAD_SW; + default: NOT_REACHED(); + } +} + +/** + * Lookup function for building road parts when building on slopes is enabled. + * @param slope The slope of the tile to examine. + * @param existing The existing neighbours. + * @param start The part that should be build first. + * @param end The part that will be build second. + * @return 0 when the build parts do not connect, 1 when they do connect once + * they are build or 2 when building the first part automatically + * builds the second part. + */ +static int32 LookupWithBuildOnSlopes(::Slope slope, Array *existing, int32 start, int32 end) +{ + if (::IsSteepSlope(slope)) { + switch (slope) { + /* On steep slopes one can only build straight roads that will be + * automatically expanded to a straight road. Just check that the existing + * road parts are in the same direction. */ + case SLOPE_STEEP_S: + case SLOPE_STEEP_W: + case SLOPE_STEEP_N: + case SLOPE_STEEP_E: + return CheckAutoExpandedRoadBits(existing, start, end) ? (existing->size == 0 ? 2 : 1) : 0; + + /* All other slopes are invalid slopes!. */ + default: + return -1; + } + } + + /* The slope is not steep. Furthermore lots of slopes are generally the + * same but are only rotated. So to reduce the amount of lookup work that + * needs to be done the data is made uniform. This means rotating the + * existing parts and updating the slope. */ + static const ::Slope base_slopes[] = { + SLOPE_FLAT, SLOPE_W, SLOPE_W, SLOPE_SW, + SLOPE_W, SLOPE_EW, SLOPE_SW, SLOPE_WSE, + SLOPE_W, SLOPE_SW, SLOPE_EW, SLOPE_WSE, + SLOPE_SW, SLOPE_WSE, SLOPE_WSE}; + static const byte base_rotates[] = {0, 0, 1, 0, 2, 0, 1, 0, 3, 3, 2, 3, 2, 2, 1}; + + if (slope >= (::Slope)lengthof(base_slopes)) { + /* This slope is an invalid slope, so ignore it. */ + return -1; + } + byte base_rotate = base_rotates[slope]; + slope = base_slopes[slope]; + + /* Some slopes don't need rotating, so return early when we know we do + * not need to rotate. */ + switch (slope) { + case SLOPE_FLAT: + /* Flat slopes can always be build. */ + return 1; + + case SLOPE_EW: + case SLOPE_WSE: + /* A slope similar to a SLOPE_EW or SLOPE_WSE will always cause + * foundations which makes them accessible from all sides. */ + return 1; + + case SLOPE_W: + case SLOPE_SW: + /* A slope for which we need perform some calculations. */ + break; + + default: + /* An invalid slope. */ + return -1; + } + + /* Now perform the actual rotation. */ + for (int j = 0; j < base_rotate; j++) { + for (int i = 0; i < existing->size; i++) { + existing->array[i] = RotateNeighbour(existing->array[i]); + } + start = RotateNeighbour(start); + end = RotateNeighbour(end); + } + + /* Create roadbits out of the data for easier handling. */ + RoadBits start_roadbits = NeighbourToRoadBits(start); + RoadBits new_roadbits = start_roadbits | NeighbourToRoadBits(end); + RoadBits existing_roadbits = ROAD_NONE; + for (int i = 0; i < existing->size; i++) { + existing_roadbits |= NeighbourToRoadBits(existing->array[i]); + } + + switch (slope) { + case SLOPE_W: + /* A slope similar to a SLOPE_W. */ + switch (new_roadbits) { + case 6: // ROAD_SE | ROAD_SW: + case 9: // ROAD_NE | ROAD_NW: + case 12: // ROAD_NE | ROAD_SE: + /* Cannot build anything with a turn from the low side. */ + return 0; + + case 5: // ROAD_SE | ROAD_NW: + case 10: // ROAD_NE | ROAD_SW: + /* A 'sloped' tile is going to be build. */ + if ((existing_roadbits | new_roadbits) != new_roadbits) { + /* There is already a foundation on the tile, or at least + * another slope that is not compatible with the new one. */ + return 0; + } + /* If the start is in the low part, it is automatically + * building the second part too. */ + return ((start_roadbits & (ROAD_NE | ROAD_SE)) && !(existing_roadbits & (ROAD_SW | ROAD_NW))) ? 2 : 1; + + default: + /* Roadbits causing a foundation are going to be build. + * When the existing roadbits are slopes (the lower bits + * are used), this cannot be done. */ + if ((existing_roadbits | new_roadbits) == new_roadbits) return 1; + return (existing_roadbits & (ROAD_NE | ROAD_SE)) ? 0 : 1; + } + + case SLOPE_SW: + /* A slope similar to a SLOPE_SW. */ + switch (new_roadbits) { + case 9: // ROAD_NE | ROAD_NW: + case 12: // ROAD_NE | ROAD_SE: + /* Cannot build anything with a turn from the low side. */ + return 0; + + case 10: // ROAD_NE | ROAD_SW: + /* A 'sloped' tile is going to be build. */ + if ((existing_roadbits | new_roadbits) != new_roadbits) { + /* There is already a foundation on the tile, or at least + * another slope that is not compatible with the new one. */ + return 0; + } + /* If the start is in the low part, it is automatically + * building the second part too. */ + return ((start_roadbits & ROAD_NE) && !(existing_roadbits & ROAD_SW)) ? 2 : 1; + + default: + /* Roadbits causing a foundation are going to be build. + * When the existing roadbits are slopes (the lower bits + * are used), this cannot be done. */ + return (existing_roadbits & ROAD_NE) ? 0 : 1; + } + + default: + NOT_REACHED(); + } +} + +/** + * Normalise all input data so we can easily handle it without needing + * to call the API lots of times or create large if-elseif-elseif-else + * constructs. + * In this case it means that a TileXY(0, -1) becomes -2 and TileXY(0, 1) + * becomes 2. TileXY(-1, 0) and TileXY(1, 0) stay respectively -1 and 1. + * Any other value means that it is an invalid tile offset. + * @param tile The tile to normalise. + * @return True if and only if the tile offset is valid. + */ +static bool NormaliseTileOffset(int32 *tile) +{ + if (*tile == 1 || *tile == -1) return true; + if (*tile == ::TileDiffXY(0, -1)) { + *tile = -2; + return true; + } + if (*tile == ::TileDiffXY(0, 1)) { + *tile = 2; + return true; + } + return false; +} + +/* static */ int32 AIRoad::CanBuildConnectedRoadParts(AITile::Slope slope_, Array *existing, TileIndex start_, TileIndex end_) +{ + ::Slope slope = (::Slope)slope_; + int32 start = start_; + int32 end = end_; + + /* The start tile and end tile cannot be the same tile either. */ + if (start == end) return -1; + + for (int i = 0; i < existing->size; i++) { + if (!NormaliseTileOffset(&existing->array[i])) return -1; + } + + if (!NormaliseTileOffset(&start)) return -1; + if (!NormaliseTileOffset(&end)) return -1; + + /* Without build on slopes the characteristics are vastly different, so use + * a different helper function (one that is much simpler). */ + return _settings_game.construction.build_on_slopes ? LookupWithBuildOnSlopes(slope, existing, start, end) : LookupWithoutBuildOnSlopes(slope, existing, start, end); +} + +/* static */ int32 AIRoad::CanBuildConnectedRoadPartsHere(TileIndex tile, TileIndex start, TileIndex end) +{ + if (!::IsValidTile(tile) || !::IsValidTile(start) || !::IsValidTile(end)) return -1; + if (::DistanceManhattan(tile, start) != 1 || ::DistanceManhattan(tile, end) != 1) return -1; + + /* ROAD_NW ROAD_SW ROAD_SE ROAD_NE */ + static const TileIndex neighbours[] = {::TileDiffXY(0, -1), ::TileDiffXY(1, 0), ::TileDiffXY(0, 1), ::TileDiffXY(-1, 0)}; + Array *existing = (Array*)alloca(sizeof(Array) + lengthof(neighbours) * sizeof(int32)); + existing->size = 0; + + ::RoadBits rb = ::ROAD_NONE; + if (::IsNormalRoadTile(tile)) { + rb = ::GetAllRoadBits(tile); + } else { + for (::RoadType rt = ::ROADTYPE_BEGIN; rt < ::ROADTYPE_END; rt++) rb |= ::GetAnyRoadBits(tile, rt); + } + for (uint i = 0; i < lengthof(neighbours); i++) { + if (HasBit(rb, i)) existing->array[existing->size++] = neighbours[i]; + } + + return AIRoad::CanBuildConnectedRoadParts(AITile::GetSlope(tile), existing, start - tile, end - tile); +} + +/** + * Check whether one can reach (possibly by building) a road piece the center + * of the neighbouring tile. This includes roads and (drive through) stations. + * @param start_tile The tile to "enter" the neighbouring tile. + * @param neighbour The direction to the neighbouring tile to "enter". + * @return true if and only if the tile is reachable. + */ +static bool NeighbourHasReachableRoad(::RoadTypes rts, TileIndex start_tile, DiagDirection neighbour) +{ + TileIndex neighbour_tile = ::TileAddByDiagDir(start_tile, neighbour); + if ((rts & ::GetRoadTypes(neighbour_tile)) == 0) return false; + + switch (::GetTileType(neighbour_tile)) { + case MP_ROAD: + return (::GetRoadTileType(neighbour_tile) != ROAD_TILE_DEPOT); + + case MP_STATION: + if (::IsDriveThroughStopTile(neighbour_tile)) { + return (::DiagDirToAxis(neighbour) == ::DiagDirToAxis(::GetRoadStopDir(neighbour_tile))); + } + return false; + + default: + return false; + } +} + +/* static */ int32 AIRoad::GetNeighbourRoadCount(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + ::RoadTypes rts = ::RoadTypeToRoadTypes((::RoadType)GetCurrentRoadType()); + int32 neighbour = 0; + + if (NeighbourHasReachableRoad(rts, tile, DIAGDIR_NE)) neighbour++; + if (NeighbourHasReachableRoad(rts, tile, DIAGDIR_SE)) neighbour++; + if (NeighbourHasReachableRoad(rts, tile, DIAGDIR_SW)) neighbour++; + if (NeighbourHasReachableRoad(rts, tile, DIAGDIR_NW)) neighbour++; + + return neighbour; +} + +/* static */ TileIndex AIRoad::GetRoadDepotFrontTile(TileIndex depot) +{ + if (!IsRoadDepotTile(depot)) return INVALID_TILE; + + return depot + ::TileOffsByDiagDir(::GetRoadDepotDirection(depot)); +} + +/* static */ TileIndex AIRoad::GetRoadStationFrontTile(TileIndex station) +{ + if (!IsRoadStationTile(station)) return INVALID_TILE; + + return station + ::TileOffsByDiagDir(::GetRoadStopDir(station)); +} + +/* static */ TileIndex AIRoad::GetDriveThroughBackTile(TileIndex station) +{ + if (!IsDriveThroughRoadStationTile(station)) return INVALID_TILE; + + return station + ::TileOffsByDiagDir(::ReverseDiagDir(::GetRoadStopDir(station))); +} + +/* static */ bool AIRoad::_BuildRoadInternal(TileIndex start, TileIndex end, bool one_way, bool full) +{ + EnforcePrecondition(false, start != end); + EnforcePrecondition(false, ::IsValidTile(start)); + EnforcePrecondition(false, ::IsValidTile(end)); + EnforcePrecondition(false, ::TileX(start) == ::TileX(end) || ::TileY(start) == ::TileY(end)); + EnforcePrecondition(false, !one_way || AIObject::GetRoadType() == ::ROADTYPE_ROAD); + + return AIObject::DoCommand(end, start, (::TileY(start) != ::TileY(end) ? 4 : 0) | (((start < end) == !full) ? 1 : 2) | (AIObject::GetRoadType() << 3) | ((one_way ? 1 : 0) << 5), CMD_BUILD_LONG_ROAD); +} + +/* static */ bool AIRoad::BuildRoad(TileIndex start, TileIndex end) +{ + return _BuildRoadInternal(start, end, false, false); +} + +/* static */ bool AIRoad::BuildOneWayRoad(TileIndex start, TileIndex end) +{ + return _BuildRoadInternal(start, end, true, false); +} + +/* static */ bool AIRoad::BuildRoadFull(TileIndex start, TileIndex end) +{ + return _BuildRoadInternal(start, end, false, true); +} + +/* static */ bool AIRoad::BuildOneWayRoadFull(TileIndex start, TileIndex end) +{ + return _BuildRoadInternal(start, end, true, true); +} + +/* static */ bool AIRoad::BuildRoadDepot(TileIndex tile, TileIndex front) +{ + EnforcePrecondition(false, tile != front); + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, ::IsValidTile(front)); + EnforcePrecondition(false, ::TileX(tile) == ::TileX(front) || ::TileY(tile) == ::TileY(front)); + + uint entrance_dir = (::TileX(tile) == ::TileX(front)) ? (::TileY(tile) < ::TileY(front) ? 1 : 3) : (::TileX(tile) < ::TileX(front) ? 2 : 0); + + return AIObject::DoCommand(tile, entrance_dir | (AIObject::GetRoadType() << 2), 0, CMD_BUILD_ROAD_DEPOT); +} + +/* static */ bool AIRoad::BuildRoadStation(TileIndex tile, TileIndex front, bool truck, bool drive_through, bool join_adjacent) +{ + EnforcePrecondition(false, tile != front); + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, ::IsValidTile(front)); + EnforcePrecondition(false, ::TileX(tile) == ::TileX(front) || ::TileY(tile) == ::TileY(front)); + + uint entrance_dir; + if (drive_through) { + entrance_dir = ::TileY(tile) != ::TileY(front); + } else { + entrance_dir = (::TileX(tile) == ::TileX(front)) ? (::TileY(tile) < ::TileY(front) ? 1 : 3) : (::TileX(tile) < ::TileX(front) ? 2 : 0); + } + + return AIObject::DoCommand(tile, entrance_dir, (join_adjacent ? 0 : 32) | (drive_through ? 2 : 0) | (truck ? 1 : 0) | (::RoadTypeToRoadTypes(AIObject::GetRoadType()) << 2) | (INVALID_STATION << 16), CMD_BUILD_ROAD_STOP); +} + +/* static */ bool AIRoad::RemoveRoad(TileIndex start, TileIndex end) +{ + EnforcePrecondition(false, ::IsValidTile(start)); + EnforcePrecondition(false, ::IsValidTile(end)); + EnforcePrecondition(false, ::TileX(start) == ::TileX(end) || ::TileY(start) == ::TileY(end)); + + return AIObject::DoCommand(end, start, (::TileY(start) != ::TileY(end) ? 4 : 0) | (start < end ? 1 : 2) | (AIObject::GetRoadType() << 3), CMD_REMOVE_LONG_ROAD); +} + +/* static */ bool AIRoad::RemoveRoadFull(TileIndex start, TileIndex end) +{ + EnforcePrecondition(false, ::IsValidTile(start)); + EnforcePrecondition(false, ::IsValidTile(end)); + EnforcePrecondition(false, ::TileX(start) == ::TileX(end) || ::TileY(start) == ::TileY(end)); + + return AIObject::DoCommand(end, start, (::TileY(start) != ::TileY(end) ? 4 : 0) | (start < end ? 2 : 1) | (AIObject::GetRoadType() << 3), CMD_REMOVE_LONG_ROAD); +} + +/* static */ bool AIRoad::RemoveRoadDepot(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, IsTileType(tile, MP_ROAD)) + EnforcePrecondition(false, GetRoadTileType(tile) == ROAD_TILE_DEPOT); + + return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR); +} + +/* static */ bool AIRoad::RemoveRoadStation(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, IsTileType(tile, MP_STATION)); + EnforcePrecondition(false, IsRoadStop(tile)); + + return AIObject::DoCommand(tile, 0, GetRoadStopType(tile), CMD_REMOVE_ROAD_STOP); +} diff --git a/src/ai/api/ai_road.hpp b/src/ai/api/ai_road.hpp new file mode 100644 index 000000000..c80f63177 --- /dev/null +++ b/src/ai/api/ai_road.hpp @@ -0,0 +1,408 @@ +/* $Id$ */ + +/** @file ai_road.hpp Everything to query and build roads. */ + +#ifndef AI_ROAD_HPP +#define AI_ROAD_HPP + +#include "ai_object.hpp" +#include "ai_error.hpp" +#include "ai_tile.hpp" + +/** + * Class that handles all road related functions. + */ +class AIRoad : public AIObject { +public: + static const char *GetClassName() { return "AIRoad"; } + + /** + * All road related error messages. + */ + enum ErrorMessages { + /** Base for road building / maintaining errors */ + ERR_ROAD_BASE = AIError::ERR_CAT_ROAD << AIError::ERR_CAT_BIT_SIZE, + + /** Road works are in progress */ + ERR_ROAD_WORKS_IN_PROGRESS, // [STR_ROAD_WORKS_IN_PROGRESS] + + /** Drive through is in the wrong direction */ + ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION, // [STR_DRIVE_THROUGH_ERROR_DIRECTION] + + /** Drive through roads can't be build on town owned roads */ + ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD, // [STR_DRIVE_THROUGH_ERROR_ON_TOWN_ROAD] + + + /** One way roads can't have junctions */ + ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS, // [STR_ERR_ONEWAY_ROADS_CAN_T_HAVE_JUNCTION] + }; + + /** + * Types of road known to the game. + */ + enum RoadType { + /* Values are important, as they represent the internal state of the game. */ + ROADTYPE_ROAD = 0, //!< Build road objects. + ROADTYPE_TRAM = 1, //!< Build tram objects. + + ROADTYPE_INVALID = -1, //!< Invalid RoadType. + }; + + /** + * Checks whether the given tile is actually a tile with road that can be + * used to traverse a tile. This excludes road depots and 'normal' road + * stations, but includes drive through stations. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has road. + */ + static bool IsRoadTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a road depot. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a road depot. + */ + static bool IsRoadDepotTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a road station. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a road station. + */ + static bool IsRoadStationTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a tile with a drive through + * road station. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile has a drive through road station. + */ + static bool IsDriveThroughRoadStationTile(TileIndex tile); + + /** + * Check if a given RoadType is available. + * @param road_type The RoadType to check for. + * @return True if this RoadType can be used. + */ + static bool IsRoadTypeAvailable(RoadType road_type); + + /** + * Get the current RoadType set for all AIRoad functions. + * @return The RoadType currently set. + */ + static RoadType GetCurrentRoadType(); + + /** + * Set the RoadType for all further AIRoad functions. + * @param road_type The RoadType to set. + */ + static void SetCurrentRoadType(RoadType road_type); + + /** + * Check if a given tile has RoadType. + * @param tile The tile to check. + * @param road_type The RoadType to check for. + * @pre AIMap::IsValidTile(tile). + * @pre IsRoadTypeAvailable(road_type). + * @return True if the tile contains a RoadType object. + */ + static bool HasRoadType(TileIndex tile, RoadType road_type); + + /** + * Checks whether the given tiles are directly connected, i.e. whether + * a road vehicle can travel from the center of the first tile to the + * center of the second tile. + * @param tile_from The source tile. + * @param tile_to The destination tile. + * @pre AIMap::IsValidTile(tile_from). + * @pre AIMap::IsValidTile(tile_to). + * @pre 'tile_from' and 'tile_to' are directly neighbouring tiles. + * @return True if and only if a road vehicle can go from tile_from to tile_to. + */ + static bool AreRoadTilesConnected(TileIndex tile_from, TileIndex tile_to); + + /** + * Lookup function for building road parts independend on whether the + * "building on slopes" setting is enabled or not. + * This implementation can be used for abstract reasoning about a tile as + * it needs the slope and existing road parts of the tile as information. + * @param slope The slope of the tile to examine. + * @param existing An array with the existing neighbours in the same format + * as "start" and "end", e.g. AIMap.GetTileIndex(0, 1). + * As a result of this all values of the existing array + * must be of type integer. + * @param start The tile from where the 'tile to be considered' will be + * entered. This is a relative tile, so valid parameters are: + * AIMap.GetTileIndex(0, 1), AIMap.GetTileIndex(0, -1), + * AIMap.GetTileIndex(1, 0) and AIMap.GetTileIndex(-1, 0). + * @param end The tile from where the 'tile to be considered' will be + * exited. This is a relative tile, sovalid parameters are: + * AIMap.GetTileIndex(0, 1), AIMap.GetTileIndex(0, -1), + * AIMap.GetTileIndex(1, 0) and AIMap.GetTileIndex(-1, 0). + * @pre start != end. + * @pre slope must be a valid slope, i.e. one specified in AITile::Slope. + * @note Passing data that would be invalid in-game, e.g. existing containing + * road parts that can not be build on a tile with the given slope, + * does not necessarily means that -1 is returned, i.e. not all + * preconditions written here or assumed by the game are extensively + * checked to make sure the data entered is valid. + * @return 0 when the build parts do not connect, 1 when they do connect once + * they are build or 2 when building the first part automatically + * builds the second part. -1 means the preconditions are not met. + */ + static int32 CanBuildConnectedRoadParts(AITile::Slope slope, struct Array *existing, TileIndex start, TileIndex end); + + /** + * Lookup function for building road parts independend on whether the + * "building on slopes" setting is enabled or not. + * This implementation can be used for reasoning about an existing tile. + * @param tile The the tile to examine. + * @param start The tile from where "tile" will be entered. + * @param end The tile from where "tile" will be exited. + * @pre start != end. + * @pre tile != start. + * @pre tile != end. + * @pre AIMap.IsValidTile(tile). + * @pre AIMap.IsValidTile(start). + * @pre AIMap.IsValidTile(end). + * @pre AIMap.GetDistanceManhattanToTile(tile, start) == 1. + * @pre AIMap.GetDistanceManhattanToTile(tile, end) == 1. + * @return 0 when the build parts do not connect, 1 when they do connect once + * they are build or 2 when building the first part automatically + * builds the second part. -1 means the preconditions are not met. + */ + static int32 CanBuildConnectedRoadPartsHere(TileIndex tile, TileIndex start, TileIndex end); + + /** + * Count how many neighbours are road. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return 0 means no neighbour road; max value is 4. + */ + static int32 GetNeighbourRoadCount(TileIndex tile); + + /** + * Gets the tile in front of a road depot. + * @param depot The road depot tile. + * @pre IsRoadDepotTile(depot). + * @return The tile in front of the depot. + */ + static TileIndex GetRoadDepotFrontTile(TileIndex depot); + + /** + * Gets the tile in front of a road station. + * @param station The road station tile. + * @pre IsRoadStationTile(station). + * @return The tile in front of the road station. + */ + static TileIndex GetRoadStationFrontTile(TileIndex station); + + /** + * Gets the tile at the back of a drive through road station. + * So, one side of the drive through station is retrieved with + * GetTileInFrontOfStation, the other with this function. + * @param station The road station tile. + * @pre IsDriveThroughRoadStationTile(station). + * @return The tile at the back of the drive through road station. + */ + static TileIndex GetDriveThroughBackTile(TileIndex station); + + /** + * Builds a road from the center of tile start to the center of tile end. + * @param start The start tile of the road. + * @param end The end tile of the road. + * @pre 'start' is not equal to 'end'. + * @pre AIMap::IsValidTile(start). + * @pre AIMap::IsValidTile(end). + * @pre 'start' and 'end' are in a straight line, i.e. + * AIMap::GetTileX(start) == AIMap::GetTileX(end) or + * AIMap::GetTileY(start) == AIMap::GetTileY(end). + * @exception AIError::ERR_ALREADY_BUILT + * @exception AIError::ERR_LAND_SLOPED_WRONG + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIRoad::ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS + * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS + * @exception AIError::ERR_VEHICLE_IN_THE_WAY + * @return Whether the road has been/can be build or not. + */ + static bool BuildRoad(TileIndex start, TileIndex end); + + /** + * Builds a one-way road from the center of tile start to the center + * of tile end. If the road already exists, it is made one-way road. + * If the road already exists and is already one-way in this direction, + * the road is made two-way again. If the road already exists but is + * one-way in the other direction, it's made a 'no'-way road (it's + * forbidden to enter the tile from any direction). + * @param start The start tile of the road. + * @param end The end tile of the road. + * @pre 'start' is not equal to 'end'. + * @pre AIMap::IsValidTile(start). + * @pre AIMap::IsValidTile(end). + * @pre 'start' and 'end' are in a straight line, i.e. + * AIMap::GetTileX(start) == AIMap::GetTileX(end) or + * AIMap::GetTileY(start) == AIMap::GetTileY(end). + * @pre GetCurrentRoadType() == ROADTYPE_ROAD. + * @exception AIError::ERR_ALREADY_BUILT + * @exception AIError::ERR_LAND_SLOPED_WRONG + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIRoad::ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS + * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS + * @exception AIError::ERR_VEHICLE_IN_THE_WAY + * @return Whether the road has been/can be build or not. + */ + static bool BuildOneWayRoad(TileIndex start, TileIndex end); + + /** + * Builds a road from the edge of tile start to the edge of tile end (both + * included). + * @param start The start tile of the road. + * @param end The end tile of the road. + * @pre 'start' is not equal to 'end'. + * @pre AIMap::IsValidTile(start). + * @pre AIMap::IsValidTile(end). + * @pre 'start' and 'end' are in a straight line, i.e. + * AIMap::GetTileX(start) == AIMap::GetTileX(end) or + * AIMap::GetTileY(start) == AIMap::GetTileY(end). + * @exception AIError::ERR_ALREADY_BUILT + * @exception AIError::ERR_LAND_SLOPED_WRONG + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIRoad::ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS + * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS + * @exception AIError::ERR_VEHICLE_IN_THE_WAY + * @return Whether the road has been/can be build or not. + */ + static bool BuildRoadFull(TileIndex start, TileIndex end); + + /** + * Builds a one-way road from the edge of tile start to the edge of tile end + * (both included). If the road already exists, it is made one-way road. + * If the road already exists and is already one-way in this direction, + * the road is made two-way again. If the road already exists but is + * one-way in the other direction, it's made a 'no'-way road (it's + * forbidden to enter the tile from any direction). + * @param start The start tile of the road. + * @param start The start tile of the road. + * @param end The end tile of the road. + * @pre 'start' is not equal to 'end'. + * @pre AIMap::IsValidTile(start). + * @pre AIMap::IsValidTile(end). + * @pre 'start' and 'end' are in a straight line, i.e. + * AIMap::GetTileX(start) == AIMap::GetTileX(end) or + * AIMap::GetTileY(start) == AIMap::GetTileY(end). + * @pre GetCurrentRoadType() == ROADTYPE_ROAD. + * @exception AIError::ERR_ALREADY_BUILT + * @exception AIError::ERR_LAND_SLOPED_WRONG + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIRoad::ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS + * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS + * @exception AIError::ERR_VEHICLE_IN_THE_WAY + * @return Whether the road has been/can be build or not. + */ + static bool BuildOneWayRoadFull(TileIndex start, TileIndex end); + + /** + * Builds a road depot. + * @param tile Place to build the depot. + * @param front The tile exactly in front of the depot. + * @pre AIMap::IsValidTile(tile). + * @pre AIMap::IsValidTile(front). + * @pre 'tile' is not equal to 'front', but in a straight line of it. + * @exception AIError::ERR_FLAT_LAND_REQUIRED + * @exception AIError::ERR_AREA_NOT_CLEAR + * @return Whether the road depot has been/can be build or not. + */ + static bool BuildRoadDepot(TileIndex tile, TileIndex front); + + /** + * Builds a road bus or truck station. + * @param tile Place to build the depot. + * @param front The tile exactly in front of the station. + * For drive-through stations either entrance side can be used. + * @param truck Whether to build a truck (true) or bus (false) station. + * @param drive_through Whether to make the station drive through or not. + * @param join_adjacent When building next to an other station, don't create a new station when this flag is true. + * @pre AIMap::IsValidTile(tile). + * @pre AIMap::IsValidTile(front). + * @pre 'tile' is not equal to 'front', but in a straight line of it. + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_FLAT_LAND_REQUIRED + * @exception AIRoad::ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION + * @exception AIRoad::ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD + * @exception AIError:ERR_VEHICLE_IN_THE_WAY + * @exception AIStation::ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION + * @exception AIStation::ERR_STATION_TOO_MANY_STATIONS + * @exception AIStation::ERR_STATION_TOO_MANY_STATIONS_IN_TOWN + * @return Whether the station has been/can be build or not. + */ + static bool BuildRoadStation(TileIndex tile, TileIndex front, bool truck, bool drive_through, bool join_adjacent); + + /** + * Removes a road from the center of tile start to the center of tile end. + * @param start The start tile of the road. + * @param end The end tile of the road. + * @pre AIMap::IsValidTile(start). + * @pre AIMap::IsValidTile(end). + * @pre 'start' and 'end' are in a straight line, i.e. + * AIMap::GetTileX(start) == AIMap::GetTileX(end) or + * AIMap::GetTileY(start) == AIMap::GetTileY(end). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIError::ERR_VEHICLE_IN_THE_WAY + * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS + * @return Whether the road has been/can be removed or not. + */ + static bool RemoveRoad(TileIndex start, TileIndex end); + + /** + * Removes a road from the edge of tile start to the edge of tile end (both + * included). + * @param start The start tile of the road. + * @param end The end tile of the road. + * @pre AIMap::IsValidTile(start). + * @pre AIMap::IsValidTile(end). + * @pre 'start' and 'end' are in a straight line, i.e. + * AIMap::GetTileX(start) == AIMap::GetTileX(end) or + * AIMap::GetTileY(start) == AIMap::GetTileY(end). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIError::ERR_VEHICLE_IN_THE_WAY + * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS + * @return Whether the road has been/can be removed or not. + */ + static bool RemoveRoadFull(TileIndex start, TileIndex end); + + /** + * Removes a road depot. + * @param tile Place to remove the depot from. + * @pre AIMap::IsValidTile(tile). + * @pre Tile is a road depot. + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIError::ERR_VEHICLE_IN_THE_WAY + * @return Whether the road depot has been/can be removed or not. + */ + static bool RemoveRoadDepot(TileIndex tile); + + /** + * Removes a road bus or truck station. + * @param tile Place to remove the station from. + * @pre AIMap::IsValidTile(tile). + * @pre Tile is a road station. + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @exception AIError::ERR_VEHICLE_IN_THE_WAY + * @return Whether the station has been/can be removed or not. + */ + static bool RemoveRoadStation(TileIndex tile); + +private: + + /** + * Internal function used by Build(OneWay)Road(Full). + */ + static bool _BuildRoadInternal(TileIndex start, TileIndex end, bool one_way, bool full); +}; + +#endif /* AI_ROAD_HPP */ diff --git a/src/ai/api/ai_road.hpp.sq b/src/ai/api/ai_road.hpp.sq new file mode 100644 index 000000000..6439ae193 --- /dev/null +++ b/src/ai/api/ai_road.hpp.sq @@ -0,0 +1,73 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_road.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIRoad::ErrorMessages GetParam(ForceType<AIRoad::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIRoad::ErrorMessages)tmp; } + template <> int Return<AIRoad::ErrorMessages>(HSQUIRRELVM vm, AIRoad::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIRoad::RoadType GetParam(ForceType<AIRoad::RoadType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIRoad::RoadType)tmp; } + template <> int Return<AIRoad::RoadType>(HSQUIRRELVM vm, AIRoad::RoadType res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIRoad to be used as Squirrel parameter */ + template <> AIRoad *GetParam(ForceType<AIRoad *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIRoad *)instance; } + template <> AIRoad &GetParam(ForceType<AIRoad &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIRoad *)instance; } + template <> const AIRoad *GetParam(ForceType<const AIRoad *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIRoad *)instance; } + template <> const AIRoad &GetParam(ForceType<const AIRoad &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIRoad *)instance; } + template <> int Return<AIRoad *>(HSQUIRRELVM vm, AIRoad *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIRoad", res, NULL, DefSQDestructorCallback<AIRoad>); return 1; } +}; // namespace SQConvert + +void SQAIRoad_Register(Squirrel *engine) { + DefSQClass <AIRoad> SQAIRoad("AIRoad"); + SQAIRoad.PreRegister(engine); + SQAIRoad.AddConstructor<void (AIRoad::*)(), 1>(engine, "x"); + + SQAIRoad.DefSQConst(engine, AIRoad::ERR_ROAD_BASE, "ERR_ROAD_BASE"); + SQAIRoad.DefSQConst(engine, AIRoad::ERR_ROAD_WORKS_IN_PROGRESS, "ERR_ROAD_WORKS_IN_PROGRESS"); + SQAIRoad.DefSQConst(engine, AIRoad::ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION, "ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION"); + SQAIRoad.DefSQConst(engine, AIRoad::ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD, "ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD"); + SQAIRoad.DefSQConst(engine, AIRoad::ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS, "ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS"); + SQAIRoad.DefSQConst(engine, AIRoad::ROADTYPE_ROAD, "ROADTYPE_ROAD"); + SQAIRoad.DefSQConst(engine, AIRoad::ROADTYPE_TRAM, "ROADTYPE_TRAM"); + SQAIRoad.DefSQConst(engine, AIRoad::ROADTYPE_INVALID, "ROADTYPE_INVALID"); + + AIError::RegisterErrorMap(STR_ROAD_WORKS_IN_PROGRESS, AIRoad::ERR_ROAD_WORKS_IN_PROGRESS); + AIError::RegisterErrorMap(STR_DRIVE_THROUGH_ERROR_DIRECTION, AIRoad::ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION); + AIError::RegisterErrorMap(STR_DRIVE_THROUGH_ERROR_ON_TOWN_ROAD, AIRoad::ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD); + AIError::RegisterErrorMap(STR_ERR_ONEWAY_ROADS_CAN_T_HAVE_JUNCTION, AIRoad::ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS); + + AIError::RegisterErrorMapString(AIRoad::ERR_ROAD_WORKS_IN_PROGRESS, "ERR_ROAD_WORKS_IN_PROGRESS"); + AIError::RegisterErrorMapString(AIRoad::ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION, "ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION"); + AIError::RegisterErrorMapString(AIRoad::ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD, "ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD"); + AIError::RegisterErrorMapString(AIRoad::ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS, "ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS"); + + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::GetClassName, "GetClassName", 1, "x"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::IsRoadTile, "IsRoadTile", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::IsRoadDepotTile, "IsRoadDepotTile", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::IsRoadStationTile, "IsRoadStationTile", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::IsDriveThroughRoadStationTile, "IsDriveThroughRoadStationTile", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::IsRoadTypeAvailable, "IsRoadTypeAvailable", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::GetCurrentRoadType, "GetCurrentRoadType", 1, "x"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::SetCurrentRoadType, "SetCurrentRoadType", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::HasRoadType, "HasRoadType", 3, "xii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::AreRoadTilesConnected, "AreRoadTilesConnected", 3, "xii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::CanBuildConnectedRoadParts, "CanBuildConnectedRoadParts", 5, "xiaii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::CanBuildConnectedRoadPartsHere, "CanBuildConnectedRoadPartsHere", 4, "xiii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::GetNeighbourRoadCount, "GetNeighbourRoadCount", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::GetRoadDepotFrontTile, "GetRoadDepotFrontTile", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::GetRoadStationFrontTile, "GetRoadStationFrontTile", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::GetDriveThroughBackTile, "GetDriveThroughBackTile", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::BuildRoad, "BuildRoad", 3, "xii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::BuildOneWayRoad, "BuildOneWayRoad", 3, "xii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::BuildRoadFull, "BuildRoadFull", 3, "xii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::BuildOneWayRoadFull, "BuildOneWayRoadFull", 3, "xii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::BuildRoadDepot, "BuildRoadDepot", 3, "xii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::BuildRoadStation, "BuildRoadStation", 6, "xiibbb"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::RemoveRoad, "RemoveRoad", 3, "xii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::RemoveRoadFull, "RemoveRoadFull", 3, "xii"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::RemoveRoadDepot, "RemoveRoadDepot", 2, "xi"); + SQAIRoad.DefSQStaticMethod(engine, &AIRoad::RemoveRoadStation, "RemoveRoadStation", 2, "xi"); + + SQAIRoad.PostRegister(engine); +} diff --git a/src/ai/api/ai_sign.cpp b/src/ai/api/ai_sign.cpp new file mode 100644 index 000000000..561b5c857 --- /dev/null +++ b/src/ai/api/ai_sign.cpp @@ -0,0 +1,73 @@ +/* $Id$ */ + +/** @file ai_sign.cpp Implementation of AISign. */ + +#include "ai_sign.hpp" +#include "table/strings.h" +#include "../ai_instance.hpp" +#include "../../openttd.h" +#include "../../command_func.h" +#include "../../core/alloc_func.hpp" +#include "../../signs_base.h" +#include "../../string_func.h" +#include "../../strings_func.h" +#include "../../tile_map.h" +#include "../../company_func.h" + +/* static */ SignID AISign::GetMaxSignID() +{ + return ::GetMaxSignIndex(); +} + +/* static */ bool AISign::IsValidSign(SignID sign_id) +{ + return ::IsValidSignID(sign_id) && ::GetSign(sign_id)->owner == _current_company; +} + +/* static */ bool AISign::SetName(SignID sign_id, const char *name) +{ + EnforcePrecondition(false, IsValidSign(sign_id)); + EnforcePrecondition(false, !::StrEmpty(name)); + EnforcePreconditionCustomError(false, ::strlen(name) < MAX_LENGTH_SIGN_NAME_BYTES, AIError::ERR_PRECONDITION_STRING_TOO_LONG); + + return AIObject::DoCommand(0, sign_id, 0, CMD_RENAME_SIGN, name); +} + +/* static */ const char *AISign::GetName(SignID sign_id) +{ + if (!IsValidSign(sign_id)) return NULL; + + static const int len = 64; + char *sign_name = MallocT<char>(len); + + ::SetDParam(0, sign_id); + ::GetString(sign_name, STR_SIGN_NAME, &sign_name[len - 1]); + + return sign_name; +} + +/* static */ TileIndex AISign::GetLocation(SignID sign_id) +{ + if (!IsValidSign(sign_id)) return INVALID_TILE; + + const Sign *sign = ::GetSign(sign_id); + return ::TileVirtXY(sign->x, sign->y); +} + +/* static */ bool AISign::RemoveSign(SignID sign_id) +{ + EnforcePrecondition(false, IsValidSign(sign_id)); + return AIObject::DoCommand(0, sign_id, 0, CMD_RENAME_SIGN, ""); +} + +/* static */ SignID AISign::BuildSign(TileIndex location, const char *text) +{ + EnforcePrecondition(INVALID_SIGN, ::IsValidTile(location)); + EnforcePrecondition(INVALID_SIGN, !::StrEmpty(text)); + EnforcePreconditionCustomError(false, ::strlen(text) < MAX_LENGTH_SIGN_NAME_BYTES, AIError::ERR_PRECONDITION_STRING_TOO_LONG); + + if (!AIObject::DoCommand(location, 0, 0, CMD_PLACE_SIGN, text, &AIInstance::DoCommandReturnSignID)) return INVALID_SIGN; + + /* In case of test-mode, we return SignID 0 */ + return 0; +} diff --git a/src/ai/api/ai_sign.hpp b/src/ai/api/ai_sign.hpp new file mode 100644 index 000000000..8bf7e0b79 --- /dev/null +++ b/src/ai/api/ai_sign.hpp @@ -0,0 +1,96 @@ +/* $Id$ */ + +/** @file ai_sign.hpp Everything to query and build signs. */ + +#ifndef AI_SIGN_HPP +#define AI_SIGN_HPP + +#include "ai_object.hpp" +#include "ai_error.hpp" +#include "ai_company.hpp" + +/** + * Class that handles all sign related functions. + */ +class AISign : public AIObject { +public: + static const char *GetClassName() { return "AISign"; } + + /** + * All sign related error messages. + */ + enum ErrorMessages { + + /** Base for sign building related errors */ + ERR_SIGN_BASE = AIError::ERR_CAT_SIGN << AIError::ERR_CAT_BIT_SIZE, + + /** Too many signs have been placed */ + ERR_SIGN_TOO_MANY_SIGNS, // [STR_2808_TOO_MANY_SIGNS] + }; + + /** + * Gets the maximum sign index; there are no valid signs with a higher index. + * @return The maximum sign index. + * @post Return value is always non-negative. + */ + static SignID GetMaxSignID(); + + /** + * Checks whether the given sign index is valid. + * @param sign_id The index to check. + * @return True if and only if the sign is valid. + */ + static bool IsValidSign(SignID sign_id); + + /** + * Set the name of a sign. + * @param sign_id The sign to set the name for. + * @param name The name for the sign. + * @pre IsValidSign(sign_id). + * @pre 'name' must have at least one character. + * @pre 'name' must have at most 30 characters. + * @exception AIError::ERR_NAME_IS_NOT_UNIQUE + * @return True if and only if the name was changed. + */ + static bool SetName(SignID sign_id, const char *name); + + /** + * Get the name of the sign. + * @param sign_id The sign to get the name of. + * @pre IsValidSign(sign_id). + * @return The name of the sign. + */ + static const char *GetName(SignID sign_id); + + /** + * Gets the location of the sign. + * @param sign_id The sign to get the location of. + * @pre IsValidSign(sign_id). + * @return The location of the sign. + */ + static TileIndex GetLocation(SignID sign_id); + + /** + * Builds a sign on the map. + * @param location The place to build the sign. + * @param text The text to place on the sign. + * @pre AIMap::IsValidTile(location). + * @pre 'text' must have at least one character. + * @pre 'text' must have at most 30 characters. + * @exception AISign::ERR_SIGN_TOO_MANY_SIGNS + * @return The SignID of the build sign (use IsValidSign() to check for validity). + * In test-mode it returns 0 if successful, or any other value to indicate + * failure. + */ + static SignID BuildSign(TileIndex location, const char *text); + + /** + * Removes a sign from the map. + * @param sign_id The sign to remove. + * @pre IsValidSign(sign_id). + * @return True if and only if the sign has been removed. + */ + static bool RemoveSign(SignID sign_id); +}; + +#endif /* AI_SIGN_HPP */ diff --git a/src/ai/api/ai_sign.hpp.sq b/src/ai/api/ai_sign.hpp.sq new file mode 100644 index 000000000..4a46e1bd8 --- /dev/null +++ b/src/ai/api/ai_sign.hpp.sq @@ -0,0 +1,41 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_sign.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AISign::ErrorMessages GetParam(ForceType<AISign::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AISign::ErrorMessages)tmp; } + template <> int Return<AISign::ErrorMessages>(HSQUIRRELVM vm, AISign::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AISign to be used as Squirrel parameter */ + template <> AISign *GetParam(ForceType<AISign *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AISign *)instance; } + template <> AISign &GetParam(ForceType<AISign &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AISign *)instance; } + template <> const AISign *GetParam(ForceType<const AISign *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AISign *)instance; } + template <> const AISign &GetParam(ForceType<const AISign &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AISign *)instance; } + template <> int Return<AISign *>(HSQUIRRELVM vm, AISign *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AISign", res, NULL, DefSQDestructorCallback<AISign>); return 1; } +}; // namespace SQConvert + +void SQAISign_Register(Squirrel *engine) { + DefSQClass <AISign> SQAISign("AISign"); + SQAISign.PreRegister(engine); + SQAISign.AddConstructor<void (AISign::*)(), 1>(engine, "x"); + + SQAISign.DefSQConst(engine, AISign::ERR_SIGN_BASE, "ERR_SIGN_BASE"); + SQAISign.DefSQConst(engine, AISign::ERR_SIGN_TOO_MANY_SIGNS, "ERR_SIGN_TOO_MANY_SIGNS"); + + AIError::RegisterErrorMap(STR_2808_TOO_MANY_SIGNS, AISign::ERR_SIGN_TOO_MANY_SIGNS); + + AIError::RegisterErrorMapString(AISign::ERR_SIGN_TOO_MANY_SIGNS, "ERR_SIGN_TOO_MANY_SIGNS"); + + SQAISign.DefSQStaticMethod(engine, &AISign::GetClassName, "GetClassName", 1, "x"); + SQAISign.DefSQStaticMethod(engine, &AISign::GetMaxSignID, "GetMaxSignID", 1, "x"); + SQAISign.DefSQStaticMethod(engine, &AISign::IsValidSign, "IsValidSign", 2, "xi"); + SQAISign.DefSQStaticMethod(engine, &AISign::SetName, "SetName", 3, "xis"); + SQAISign.DefSQStaticMethod(engine, &AISign::GetName, "GetName", 2, "xi"); + SQAISign.DefSQStaticMethod(engine, &AISign::GetLocation, "GetLocation", 2, "xi"); + SQAISign.DefSQStaticMethod(engine, &AISign::BuildSign, "BuildSign", 3, "xis"); + SQAISign.DefSQStaticMethod(engine, &AISign::RemoveSign, "RemoveSign", 2, "xi"); + + SQAISign.PostRegister(engine); +} diff --git a/src/ai/api/ai_station.cpp b/src/ai/api/ai_station.cpp new file mode 100644 index 000000000..ab171a307 --- /dev/null +++ b/src/ai/api/ai_station.cpp @@ -0,0 +1,146 @@ +/* $Id$ */ + +/** @file ai_station.cpp Implementation of AIStation. */ + +#include "ai_station.hpp" +#include "ai_cargo.hpp" +#include "ai_map.hpp" +#include "ai_town.hpp" +#include "../../openttd.h" +#include "../../command_func.h" +#include "../../debug.h" +#include "../../station_map.h" +#include "../../variables.h" +#include "../../string_func.h" +#include "../../strings_func.h" +#include "../../core/alloc_func.hpp" +#include "../../company_func.h" +#include "../../settings_type.h" +#include "../../town.h" +#include "table/strings.h" + +/* static */ bool AIStation::IsValidStation(StationID station_id) +{ + return ::IsValidStationID(station_id) && ::GetStation(station_id)->owner == _current_company; +} + +/* static */ StationID AIStation::GetStationID(TileIndex tile) +{ + if (!::IsTileType(tile, MP_STATION)) return INVALID_STATION; + return ::GetStationIndex(tile); +} + +/* static */ const char *AIStation::GetName(StationID station_id) +{ + if (!IsValidStation(station_id)) return NULL; + + static const int len = 64; + char *station_name = MallocT<char>(len); + + ::SetDParam(0, GetStation(station_id)->index); + ::GetString(station_name, STR_STATION, &station_name[len - 1]); + return station_name; +} + +/* static */ bool AIStation::SetName(StationID station_id, const char *name) +{ + EnforcePrecondition(false, IsValidStation(station_id)); + EnforcePrecondition(false, !::StrEmpty(name)); + EnforcePreconditionCustomError(false, ::strlen(name) < MAX_LENGTH_STATION_NAME_BYTES, AIError::ERR_PRECONDITION_STRING_TOO_LONG); + + return AIObject::DoCommand(0, station_id, 0, CMD_RENAME_STATION, name); +} + +/* static */ TileIndex AIStation::GetLocation(StationID station_id) +{ + if (!IsValidStation(station_id)) return INVALID_TILE; + + return ::GetStation(station_id)->xy; +} + +/* static */ int32 AIStation::GetCargoWaiting(StationID station_id, CargoID cargo_id) +{ + if (!IsValidStation(station_id)) return -1; + if (!AICargo::IsValidCargo(cargo_id)) return -1; + + return ::GetStation(station_id)->goods[cargo_id].cargo.Count(); +} + +/* static */ int32 AIStation::GetCargoRating(StationID station_id, CargoID cargo_id) +{ + if (!IsValidStation(station_id)) return -1; + if (!AICargo::IsValidCargo(cargo_id)) return -1; + + return ::GetStation(station_id)->goods[cargo_id].rating * 101 >> 8; +} + +/* static */ int32 AIStation::GetCoverageRadius(AIStation::StationType station_type) +{ + if (station_type == STATION_AIRPORT) { + DEBUG(ai, 0, "GetCoverageRadius(): coverage radius of airports needs to be requested via AIAirport::GetAirportCoverageRadius(), as it requires AirportType"); + return -1; + } + if (CountBits(station_type) != 1) return -1; + if (!_settings_game.station.modified_catchment) return CA_UNMODIFIED; + + switch (station_type) { + case STATION_TRAIN: return CA_TRAIN; + case STATION_TRUCK_STOP: return CA_TRUCK; + case STATION_BUS_STOP: return CA_BUS; + case STATION_DOCK: return CA_DOCK; + default: return CA_NONE; + } +} + +/* static */ int32 AIStation::GetDistanceManhattanToTile(StationID station_id, TileIndex tile) +{ + if (!IsValidStation(station_id)) return -1; + + return AIMap::DistanceManhattan(tile, GetLocation(station_id)); +} + +/* static */ int32 AIStation::GetDistanceSquareToTile(StationID station_id, TileIndex tile) +{ + if (!IsValidStation(station_id)) return -1; + + return AIMap::DistanceSquare(tile, GetLocation(station_id)); +} + +/* static */ bool AIStation::IsWithinTownInfluence(StationID station_id, TownID town_id) +{ + if (!IsValidStation(station_id)) return false; + + return AITown::IsWithinTownInfluence(town_id, GetLocation(station_id)); +} + +/* static */ bool AIStation::HasStationType(StationID station_id, StationType station_type) +{ + if (!IsValidStation(station_id)) return false; + if (CountBits(station_type) != 1) return false; + + return (::GetStation(station_id)->facilities & station_type) != 0; +} + +/* static */ bool AIStation::HasRoadType(StationID station_id, AIRoad::RoadType road_type) +{ + if (!IsValidStation(station_id)) return false; + if (!AIRoad::IsRoadTypeAvailable(road_type)) return false; + + ::RoadTypes r = RoadTypeToRoadTypes((::RoadType)road_type); + + for (const RoadStop *rs = ::GetStation(station_id)->GetPrimaryRoadStop(ROADSTOP_BUS); rs != NULL; rs = rs->next) { + if ((::GetRoadTypes(rs->xy) & r) != 0) return true; + } + for (const RoadStop *rs = ::GetStation(station_id)->GetPrimaryRoadStop(ROADSTOP_TRUCK); rs != NULL; rs = rs->next) { + if ((::GetRoadTypes(rs->xy) & r) != 0) return true; + } + + return false; +} + +/* static */ TownID AIStation::GetNearestTown(StationID station_id) +{ + if (!IsValidStation(station_id)) return INVALID_TOWN; + + return ::GetStation(station_id)->town->index; +} diff --git a/src/ai/api/ai_station.hpp b/src/ai/api/ai_station.hpp new file mode 100644 index 000000000..6e263c912 --- /dev/null +++ b/src/ai/api/ai_station.hpp @@ -0,0 +1,184 @@ +/* $Id$ */ + +/** @file ai_station.hpp Everything to query and build stations. */ + +#ifndef AI_STATION_HPP +#define AI_STATION_HPP + +#include "ai_object.hpp" +#include "ai_error.hpp" +#include "ai_road.hpp" + +/** + * Class that handles all station related functions. + */ +class AIStation : public AIObject { +public: + static const char *GetClassName() { return "AIStation"; } + + /** + * All station related error messages. + */ + enum ErrorMessages { + /** Base for station related errors */ + ERR_STATION_BASE = AIError::ERR_CAT_STATION << AIError::ERR_CAT_BIT_SIZE, + + /** The station size exceeds the station spread */ + ERR_STATION_TOO_LARGE, // [STR_306C_STATION_TOO_SPREAD_OUT] + + /** The station is build too close to another station, airport or dock */ + ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION, // [STR_300D_TOO_CLOSE_TO_ANOTHER_AIRPORT, STR_3009_TOO_CLOSE_TO_ANOTHER_STATION, STR_304C_TOO_CLOSE_TO_ANOTHER_DOCK] + + /** There are too many stations, airports and docks in the game */ + ERR_STATION_TOO_MANY_STATIONS, // [STR_3008_TOO_MANY_STATIONS_LOADING, STR_TOO_MANY_TRUCK_STOPS, STR_TOO_MANY_BUS_STOPS] + + /** There are too many stations, airports of docks in a town */ + ERR_STATION_TOO_MANY_STATIONS_IN_TOWN, // [STR_3007_TOO_MANY_STATIONS_LOADING] + }; + + /** + * Type of stations known in the game. + */ + enum StationType { + /* Values are important, as they represent the internal state of the game. */ + STATION_TRAIN = 0x01, //!< Train station + STATION_TRUCK_STOP = 0x02, //!< Truck station + STATION_BUS_STOP = 0x04, //!< Bus station + STATION_AIRPORT = 0x08, //!< Airport + STATION_DOCK = 0x10, //!< Dock + STATION_ANY = 0x1F, //!< All station types + }; + + /** + * Checks whether the given station is valid and owned by you. + * @param station_id The station to check. + * @return True if and only if the station is valid. + */ + static bool IsValidStation(StationID station_id); + + /** + * Get the StationID of a tile, if there is a station. + * @param tile The tile to find the stationID of + * @return StationID of the station. + * @post Use IsValidStation() to see if the station is valid. + */ + static StationID GetStationID(TileIndex tile); + + /** + * Get the name of a station. + * @param station_id The station to get the name of. + * @pre IsValidStation(station_id). + * @return The name of the station. + */ + static const char *GetName(StationID station_id); + + /** + * Set the name this station. + * @param station_id The station to set the name of. + * @param name The new name of the station. + * @pre IsValidStation(station_id). + * @pre 'name' must have at least one character. + * @pre 'name' must have at most 30 characters. + * @exception AIError::ERR_NAME_IS_NOT_UNIQUE + * @return True if the name was changed. + */ + static bool SetName(StationID station_id, const char *name); + + /** + * Get the current location of a station. + * @param station_id The station to get the location of. + * @pre IsValidStation(station_id). + * @return The tile the station is currently on. + */ + static TileIndex GetLocation(StationID station_id); + + /** + * See how much cargo there is waiting on a station. + * @param station_id The station to get the cargo-waiting of. + * @param cargo_id The cargo to get the cargo-waiting of. + * @pre IsValidStation(station_id). + * @pre IsValidCargo(cargo_id). + * @return The amount of units waiting at the station. + */ + static int32 GetCargoWaiting(StationID station_id, CargoID cargo_id); + + /** + * See how high the rating is of a cargo on a station. + * @param station_id The station to get the cargo-rating of. + * @param cargo_id The cargo to get the cargo-rating of. + * @pre IsValidStation(station_id). + * @pre IsValidCargo(cargo_id). + * @return The rating in percent of the cargo on the station. + */ + static int32 GetCargoRating(StationID station_id, CargoID cargo_id); + + /** + * Get the coverage radius of this type of station. + * @param station_type The type of station. + * @return The radius in tiles. + */ + static int32 GetCoverageRadius(AIStation::StationType station_type); + + /** + * Get the manhattan distance from the tile to the AIStation::GetLocation() + * of the station. + * @param station_id The station to get the distance to. + * @param tile The tile to get the distance to. + * @pre IsValidStation(station_id). + * @return The distance between station and tile. + */ + static int32 GetDistanceManhattanToTile(StationID station_id, TileIndex tile); + + /** + * Get the square distance from the tile to the AIStation::GetLocation() + * of the station. + * @param station_id The station to get the distance to. + * @param tile The tile to get the distance to. + * @pre IsValidStation(station_id). + * @return The distance between station and tile. + */ + static int32 GetDistanceSquareToTile(StationID station_id, TileIndex tile); + + /** + * Find out if this station is within the rating influence of a town. + * Stations within the radius influence the rating of the town. + * @param station_id The station to check. + * @param town_id The town to check. + * @return True if the tile is within the rating influence of the town. + */ + static bool IsWithinTownInfluence(StationID station_id, TownID town_id); + + /** + * Check if any part of the station contains a station of the type + * StationType + * @param station_id The station to look at. + * @param station_type The StationType to look for. + * @return True if the station has a station part of the type StationType. + */ + static bool HasStationType(StationID station_id, StationType station_type); + + /** + * Check if any part of the station contains a station of the type + * RoadType. + * @param station_id The station to look at. + * @param road_type The RoadType to look for. + * @return True if the station has a station part of the type RoadType. + */ + static bool HasRoadType(StationID station_id, AIRoad::RoadType road_type); + + /** + * Get the town that was nearest to the given station when the station was built. + * @param station_id The station to look at. + * @return The TownID of the town whose center tile was closest to the station + * at the time the station was built. + * @note There is no guarantee that the station is even near the returned town + * nor that the returns town is closest to the station now. A station that was + * 'walked' to the other end of the map will still return the same town. Also, + * towns grow, towns change. So don't depend on this value too much. + */ + static TownID GetNearestTown(StationID station_id); +}; + +DECLARE_ENUM_AS_BIT_SET(AIStation::StationType); + +#endif /* AI_STATION_HPP */ diff --git a/src/ai/api/ai_station.hpp.sq b/src/ai/api/ai_station.hpp.sq new file mode 100644 index 000000000..f752d8d9a --- /dev/null +++ b/src/ai/api/ai_station.hpp.sq @@ -0,0 +1,69 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_station.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIStation::ErrorMessages GetParam(ForceType<AIStation::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIStation::ErrorMessages)tmp; } + template <> int Return<AIStation::ErrorMessages>(HSQUIRRELVM vm, AIStation::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIStation::StationType GetParam(ForceType<AIStation::StationType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIStation::StationType)tmp; } + template <> int Return<AIStation::StationType>(HSQUIRRELVM vm, AIStation::StationType res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIStation to be used as Squirrel parameter */ + template <> AIStation *GetParam(ForceType<AIStation *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIStation *)instance; } + template <> AIStation &GetParam(ForceType<AIStation &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStation *)instance; } + template <> const AIStation *GetParam(ForceType<const AIStation *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIStation *)instance; } + template <> const AIStation &GetParam(ForceType<const AIStation &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStation *)instance; } + template <> int Return<AIStation *>(HSQUIRRELVM vm, AIStation *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStation", res, NULL, DefSQDestructorCallback<AIStation>); return 1; } +}; // namespace SQConvert + +void SQAIStation_Register(Squirrel *engine) { + DefSQClass <AIStation> SQAIStation("AIStation"); + SQAIStation.PreRegister(engine); + SQAIStation.AddConstructor<void (AIStation::*)(), 1>(engine, "x"); + + SQAIStation.DefSQConst(engine, AIStation::ERR_STATION_BASE, "ERR_STATION_BASE"); + SQAIStation.DefSQConst(engine, AIStation::ERR_STATION_TOO_LARGE, "ERR_STATION_TOO_LARGE"); + SQAIStation.DefSQConst(engine, AIStation::ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION, "ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION"); + SQAIStation.DefSQConst(engine, AIStation::ERR_STATION_TOO_MANY_STATIONS, "ERR_STATION_TOO_MANY_STATIONS"); + SQAIStation.DefSQConst(engine, AIStation::ERR_STATION_TOO_MANY_STATIONS_IN_TOWN, "ERR_STATION_TOO_MANY_STATIONS_IN_TOWN"); + SQAIStation.DefSQConst(engine, AIStation::STATION_TRAIN, "STATION_TRAIN"); + SQAIStation.DefSQConst(engine, AIStation::STATION_TRUCK_STOP, "STATION_TRUCK_STOP"); + SQAIStation.DefSQConst(engine, AIStation::STATION_BUS_STOP, "STATION_BUS_STOP"); + SQAIStation.DefSQConst(engine, AIStation::STATION_AIRPORT, "STATION_AIRPORT"); + SQAIStation.DefSQConst(engine, AIStation::STATION_DOCK, "STATION_DOCK"); + SQAIStation.DefSQConst(engine, AIStation::STATION_ANY, "STATION_ANY"); + + AIError::RegisterErrorMap(STR_306C_STATION_TOO_SPREAD_OUT, AIStation::ERR_STATION_TOO_LARGE); + AIError::RegisterErrorMap(STR_300D_TOO_CLOSE_TO_ANOTHER_AIRPORT, AIStation::ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION); + AIError::RegisterErrorMap(STR_3009_TOO_CLOSE_TO_ANOTHER_STATION, AIStation::ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION); + AIError::RegisterErrorMap(STR_304C_TOO_CLOSE_TO_ANOTHER_DOCK, AIStation::ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION); + AIError::RegisterErrorMap(STR_3008_TOO_MANY_STATIONS_LOADING, AIStation::ERR_STATION_TOO_MANY_STATIONS); + AIError::RegisterErrorMap(STR_TOO_MANY_TRUCK_STOPS, AIStation::ERR_STATION_TOO_MANY_STATIONS); + AIError::RegisterErrorMap(STR_TOO_MANY_BUS_STOPS, AIStation::ERR_STATION_TOO_MANY_STATIONS); + AIError::RegisterErrorMap(STR_3007_TOO_MANY_STATIONS_LOADING, AIStation::ERR_STATION_TOO_MANY_STATIONS_IN_TOWN); + + AIError::RegisterErrorMapString(AIStation::ERR_STATION_TOO_LARGE, "ERR_STATION_TOO_LARGE"); + AIError::RegisterErrorMapString(AIStation::ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION, "ERR_STATION_TOO_CLOSE_TO_ANOTHER_STATION"); + AIError::RegisterErrorMapString(AIStation::ERR_STATION_TOO_MANY_STATIONS, "ERR_STATION_TOO_MANY_STATIONS"); + AIError::RegisterErrorMapString(AIStation::ERR_STATION_TOO_MANY_STATIONS_IN_TOWN, "ERR_STATION_TOO_MANY_STATIONS_IN_TOWN"); + + SQAIStation.DefSQStaticMethod(engine, &AIStation::GetClassName, "GetClassName", 1, "x"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::IsValidStation, "IsValidStation", 2, "xi"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::GetStationID, "GetStationID", 2, "xi"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::GetName, "GetName", 2, "xi"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::SetName, "SetName", 3, "xis"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::GetLocation, "GetLocation", 2, "xi"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::GetCargoWaiting, "GetCargoWaiting", 3, "xii"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::GetCargoRating, "GetCargoRating", 3, "xii"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::GetCoverageRadius, "GetCoverageRadius", 2, "xi"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::GetDistanceManhattanToTile, "GetDistanceManhattanToTile", 3, "xii"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::GetDistanceSquareToTile, "GetDistanceSquareToTile", 3, "xii"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::IsWithinTownInfluence, "IsWithinTownInfluence", 3, "xii"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::HasStationType, "HasStationType", 3, "xii"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::HasRoadType, "HasRoadType", 3, "xii"); + SQAIStation.DefSQStaticMethod(engine, &AIStation::GetNearestTown, "GetNearestTown", 2, "xi"); + + SQAIStation.PostRegister(engine); +} diff --git a/src/ai/api/ai_stationlist.cpp b/src/ai/api/ai_stationlist.cpp new file mode 100644 index 000000000..43cb33878 --- /dev/null +++ b/src/ai/api/ai_stationlist.cpp @@ -0,0 +1,29 @@ +/* $Id$ */ + +/** @file ai_stationlist.cpp Implementation of AIStationList and friends. */ + +#include "ai_stationlist.hpp" +#include "ai_vehicle.hpp" +#include "../../openttd.h" +#include "../../company_func.h" +#include "../../station_base.h" +#include "../../vehicle_base.h" + +AIStationList::AIStationList(AIStation::StationType station_type) +{ + Station *st; + FOR_ALL_STATIONS(st) { + if (st->owner == _current_company && (st->facilities & station_type) != 0) this->AddItem(st->index); + } +} + +AIStationList_Vehicle::AIStationList_Vehicle(VehicleID vehicle_id) +{ + if (!AIVehicle::IsValidVehicle(vehicle_id)) return; + + Vehicle *v = ::GetVehicle(vehicle_id); + + for (Order *o = v->GetFirstOrder(); o != NULL; o = o->next) { + if (o->IsType(OT_GOTO_STATION)) this->AddItem(o->GetDestination()); + } +} diff --git a/src/ai/api/ai_stationlist.hpp b/src/ai/api/ai_stationlist.hpp new file mode 100644 index 000000000..b6b1a7d1f --- /dev/null +++ b/src/ai/api/ai_stationlist.hpp @@ -0,0 +1,39 @@ +/* $Id$ */ + +/** @file ai_stationlist.hpp List all the stations (you own). */ + +#ifndef AI_STATIONLIST_HPP +#define AI_STATIONLIST_HPP + +#include "ai_abstractlist.hpp" +#include "ai_station.hpp" + +/** + * Creates a list of stations of which you are the owner. + * @ingroup AIList + */ +class AIStationList : public AIAbstractList { +public: + static const char *GetClassName() { return "AIStationList"; } + + /** + * @param station_type The type of station to make a list of stations for. + */ + AIStationList(AIStation::StationType station_type); +}; + +/** + * Creates a list of stations which the vehicle has in its orders. + * @ingroup AIList + */ +class AIStationList_Vehicle : public AIAbstractList { +public: + static const char *GetClassName() { return "AIStationList_Vehicle"; } + + /** + * @param vehicle_id The vehicle to get the list of stations he has in its orders from. + */ + AIStationList_Vehicle(VehicleID vehicle_id); +}; + +#endif /* AI_STATIONLIST_HPP */ diff --git a/src/ai/api/ai_stationlist.hpp.sq b/src/ai/api/ai_stationlist.hpp.sq new file mode 100644 index 000000000..d3e5bcd4c --- /dev/null +++ b/src/ai/api/ai_stationlist.hpp.sq @@ -0,0 +1,42 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_stationlist.hpp" + +namespace SQConvert { + /* Allow AIStationList to be used as Squirrel parameter */ + template <> AIStationList *GetParam(ForceType<AIStationList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIStationList *)instance; } + template <> AIStationList &GetParam(ForceType<AIStationList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationList *)instance; } + template <> const AIStationList *GetParam(ForceType<const AIStationList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIStationList *)instance; } + template <> const AIStationList &GetParam(ForceType<const AIStationList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationList *)instance; } + template <> int Return<AIStationList *>(HSQUIRRELVM vm, AIStationList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationList", res, NULL, DefSQDestructorCallback<AIStationList>); return 1; } +}; // namespace SQConvert + +void SQAIStationList_Register(Squirrel *engine) { + DefSQClass <AIStationList> SQAIStationList("AIStationList"); + SQAIStationList.PreRegister(engine, "AIAbstractList"); + SQAIStationList.AddConstructor<void (AIStationList::*)(AIStation::StationType station_type), 2>(engine, "xi"); + + SQAIStationList.DefSQStaticMethod(engine, &AIStationList::GetClassName, "GetClassName", 1, "x"); + + SQAIStationList.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIStationList_Vehicle to be used as Squirrel parameter */ + template <> AIStationList_Vehicle *GetParam(ForceType<AIStationList_Vehicle *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIStationList_Vehicle *)instance; } + template <> AIStationList_Vehicle &GetParam(ForceType<AIStationList_Vehicle &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationList_Vehicle *)instance; } + template <> const AIStationList_Vehicle *GetParam(ForceType<const AIStationList_Vehicle *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIStationList_Vehicle *)instance; } + template <> const AIStationList_Vehicle &GetParam(ForceType<const AIStationList_Vehicle &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationList_Vehicle *)instance; } + template <> int Return<AIStationList_Vehicle *>(HSQUIRRELVM vm, AIStationList_Vehicle *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationList_Vehicle", res, NULL, DefSQDestructorCallback<AIStationList_Vehicle>); return 1; } +}; // namespace SQConvert + +void SQAIStationList_Vehicle_Register(Squirrel *engine) { + DefSQClass <AIStationList_Vehicle> SQAIStationList_Vehicle("AIStationList_Vehicle"); + SQAIStationList_Vehicle.PreRegister(engine, "AIAbstractList"); + SQAIStationList_Vehicle.AddConstructor<void (AIStationList_Vehicle::*)(VehicleID vehicle_id), 2>(engine, "xi"); + + SQAIStationList_Vehicle.DefSQStaticMethod(engine, &AIStationList_Vehicle::GetClassName, "GetClassName", 1, "x"); + + SQAIStationList_Vehicle.PostRegister(engine); +} diff --git a/src/ai/api/ai_subsidy.cpp b/src/ai/api/ai_subsidy.cpp new file mode 100644 index 000000000..893b65e7d --- /dev/null +++ b/src/ai/api/ai_subsidy.cpp @@ -0,0 +1,94 @@ +/* $Id$ */ + +/** @file ai_subsidy.cpp Implementation of AISubsidy. */ + +#include "ai_subsidy.hpp" +#include "ai_error.hpp" +#include "ai_company.hpp" +#include "ai_date.hpp" +#include "../../openttd.h" +#include "../../economy_func.h" +#include "../../station_base.h" +#include "../../cargotype.h" + +/* static */ bool AISubsidy::IsValidSubsidy(SubsidyID subsidy_id) +{ + return subsidy_id < lengthof(_subsidies) && _subsidies[subsidy_id].cargo_type != CT_INVALID; +} + +/* static */ bool AISubsidy::IsAwarded(SubsidyID subsidy_id) +{ + if (!IsValidSubsidy(subsidy_id)) return false; + + return _subsidies[subsidy_id].age >= 12; +} + +/* static */ AICompany::CompanyID AISubsidy::GetAwardedTo(SubsidyID subsidy_id) +{ + if (!IsAwarded(subsidy_id)) return AICompany::INVALID_COMPANY; + + return (AICompany::CompanyID)((byte)GetStation(_subsidies[subsidy_id].from)->owner); +} + +/* static */ int32 AISubsidy::GetExpireDate(SubsidyID subsidy_id) +{ + if (!IsValidSubsidy(subsidy_id)) return -1; + + int year = AIDate::GetYear(AIDate::GetCurrentDate()); + int month = AIDate::GetMonth(AIDate::GetCurrentDate()); + + if (IsAwarded(subsidy_id)) { + month += 24 - _subsidies[subsidy_id].age; + } else { + month += 12 - _subsidies[subsidy_id].age; + } + + year += (month - 1) / 12; + month = ((month - 1) % 12) + 1; + + return AIDate::GetDate(year, month, 1); +} + +/* static */ CargoID AISubsidy::GetCargoType(SubsidyID subsidy_id) +{ + if (!IsValidSubsidy(subsidy_id)) return CT_INVALID; + + return _subsidies[subsidy_id].cargo_type; +} + +/* static */ bool AISubsidy::SourceIsTown(SubsidyID subsidy_id) +{ + if (!IsValidSubsidy(subsidy_id) || IsAwarded(subsidy_id)) return false; + + return GetCargo(GetCargoType(subsidy_id))->town_effect == TE_PASSENGERS || + GetCargo(GetCargoType(subsidy_id))->town_effect == TE_MAIL; +} + +/* static */ int32 AISubsidy::GetSource(SubsidyID subsidy_id) +{ + if (!IsValidSubsidy(subsidy_id)) return INVALID_STATION; + + return _subsidies[subsidy_id].from; +} + +/* static */ bool AISubsidy::DestinationIsTown(SubsidyID subsidy_id) +{ + if (!IsValidSubsidy(subsidy_id) || IsAwarded(subsidy_id)) return false; + + switch (GetCargo(GetCargoType(subsidy_id))->town_effect) { + case TE_PASSENGERS: + case TE_MAIL: + case TE_GOODS: + case TE_FOOD: + return true; + default: + return false; + } +} + +/* static */ int32 AISubsidy::GetDestination(SubsidyID subsidy_id) +{ + if (!IsValidSubsidy(subsidy_id)) return INVALID_STATION; + + return _subsidies[subsidy_id].to; +} diff --git a/src/ai/api/ai_subsidy.hpp b/src/ai/api/ai_subsidy.hpp new file mode 100644 index 000000000..7be86b0e8 --- /dev/null +++ b/src/ai/api/ai_subsidy.hpp @@ -0,0 +1,101 @@ +/* $Id$ */ + +/** @file ai_subsidy.hpp Everything to query subsidies. */ + +#ifndef AI_SUBSIDY_HPP +#define AI_SUBSIDY_HPP + +#include "ai_object.hpp" +#include "ai_company.hpp" + +/** + * Class that handles all subsidy related functions. + */ +class AISubsidy : public AIObject { +public: + static const char *GetClassName() { return "AISubsidy"; } + + /** + * Check whether this is a valid SubsidyID. + * @param subsidy_id The SubsidyID to check. + * @return True if and only if this subsidy is still valid. + */ + static bool IsValidSubsidy(SubsidyID subsidy_id); + + /** + * Checks whether this subsidy is already awarded to some company. + * @param subsidy_id The SubsidyID to check. + * @pre IsValidSubsidy(subsidy). + * @return True if and only if this subsidy is already awarded. + */ + static bool IsAwarded(SubsidyID subsidy_id); + + /** + * Get the company index of the company this subsidy is awarded to. + * @param subsidy_id The SubsidyID to check. + * @pre IsAwarded(subsidy_id). + * @return The companyindex of the company this subsidy is awarded to. + */ + static AICompany::CompanyID GetAwardedTo(SubsidyID subsidy_id); + + /** + * Get the date this subsidy expires. In case the subsidy is already + * awarded, return the date the subsidy expires, else, return the date the + * offer expires. + * @param subsidy_id The SubsidyID to check. + * @pre IsValidSubsidy(subsidy_id). + * @return The last valid date of this subsidy. + * @note The return value of this function will change if the subsidy is + * awarded. + */ + static int32 GetExpireDate(SubsidyID subsidy_id); + + /** + * Get the cargo type that has to be transported in order to be awarded this + * subsidy. + * @param subsidy_id The SubsidyID to check. + * @pre IsValidSubsidy(subsidy_id). + * @return The cargo type to transport. + */ + static CargoID GetCargoType(SubsidyID subsidy_id); + + /** + * Is the source of the subsidy a town or an industry. + * @param subsidy_id The SubsidyID to check. + * @pre IsValidSubsidy(subsidy_id) && !IsAwarded(subsidy_id). + * @return True if the source is a town, false if it is an industry. + */ + static bool SourceIsTown(SubsidyID subsidy_id); + + /** + * Return the source TownID/IndustryID/StationID the subsidy is for. + * 1) IsAwarded(subsidy_id) -> return the StationID the subsidy is awarded to. + * 2) !IsAwarded(subsidy_id) && SourceIsTown(subsidy_id) -> return the TownID. + * 3) !IsAwarded(subsidy_id) && !SourceIsTown(subsidy_id) -> return the IndustryID. + * @param subsidy_id The SubsidyID to check. + * @pre IsValidSubsidy(subsidy_id). + * @return One of TownID/IndustryID/StationID. + */ + static int32 GetSource(SubsidyID subsidy_id); + + /** + * Is the destination of the subsidy a town or an industry. + * @param subsidy_id The SubsidyID to check. + * @pre IsValidSubsidy(subsidy_id) && !IsAwarded(subsidy_id). + * @return True if the destination is a town, false if it is an industry. + */ + static bool DestinationIsTown(SubsidyID subsidy_id); + + /** + * Return the destination TownID/IndustryID/StationID the subsidy is for. + * 1) IsAwarded(subsidy_id) -> return the StationID the subsidy is awarded to. + * 2) !IsAwarded(subsidy_id) && SourceIsTown(subsidy_id) -> return the TownID. + * 3) !IsAwarded(subsidy_id) && !SourceIsTown(subsidy_id) -> return the IndustryID. + * @param subsidy_id the SubsidyID to check. + * @pre IsValidSubsidy(subsidy_id). + * @return One of TownID/IndustryID/StationID. + */ + static int32 GetDestination(SubsidyID subsidy_id); +}; + +#endif /* AI_SUBSIDY_HPP */ diff --git a/src/ai/api/ai_subsidy.hpp.sq b/src/ai/api/ai_subsidy.hpp.sq new file mode 100644 index 000000000..41ed75077 --- /dev/null +++ b/src/ai/api/ai_subsidy.hpp.sq @@ -0,0 +1,32 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_subsidy.hpp" + +namespace SQConvert { + /* Allow AISubsidy to be used as Squirrel parameter */ + template <> AISubsidy *GetParam(ForceType<AISubsidy *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AISubsidy *)instance; } + template <> AISubsidy &GetParam(ForceType<AISubsidy &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AISubsidy *)instance; } + template <> const AISubsidy *GetParam(ForceType<const AISubsidy *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AISubsidy *)instance; } + template <> const AISubsidy &GetParam(ForceType<const AISubsidy &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AISubsidy *)instance; } + template <> int Return<AISubsidy *>(HSQUIRRELVM vm, AISubsidy *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AISubsidy", res, NULL, DefSQDestructorCallback<AISubsidy>); return 1; } +}; // namespace SQConvert + +void SQAISubsidy_Register(Squirrel *engine) { + DefSQClass <AISubsidy> SQAISubsidy("AISubsidy"); + SQAISubsidy.PreRegister(engine); + SQAISubsidy.AddConstructor<void (AISubsidy::*)(), 1>(engine, "x"); + + SQAISubsidy.DefSQStaticMethod(engine, &AISubsidy::GetClassName, "GetClassName", 1, "x"); + SQAISubsidy.DefSQStaticMethod(engine, &AISubsidy::IsValidSubsidy, "IsValidSubsidy", 2, "xi"); + SQAISubsidy.DefSQStaticMethod(engine, &AISubsidy::IsAwarded, "IsAwarded", 2, "xi"); + SQAISubsidy.DefSQStaticMethod(engine, &AISubsidy::GetAwardedTo, "GetAwardedTo", 2, "xi"); + SQAISubsidy.DefSQStaticMethod(engine, &AISubsidy::GetExpireDate, "GetExpireDate", 2, "xi"); + SQAISubsidy.DefSQStaticMethod(engine, &AISubsidy::GetCargoType, "GetCargoType", 2, "xi"); + SQAISubsidy.DefSQStaticMethod(engine, &AISubsidy::SourceIsTown, "SourceIsTown", 2, "xi"); + SQAISubsidy.DefSQStaticMethod(engine, &AISubsidy::GetSource, "GetSource", 2, "xi"); + SQAISubsidy.DefSQStaticMethod(engine, &AISubsidy::DestinationIsTown, "DestinationIsTown", 2, "xi"); + SQAISubsidy.DefSQStaticMethod(engine, &AISubsidy::GetDestination, "GetDestination", 2, "xi"); + + SQAISubsidy.PostRegister(engine); +} diff --git a/src/ai/api/ai_subsidylist.cpp b/src/ai/api/ai_subsidylist.cpp new file mode 100644 index 000000000..8e5d96ad9 --- /dev/null +++ b/src/ai/api/ai_subsidylist.cpp @@ -0,0 +1,14 @@ +/* $Id$ */ + +/** @file ai_subsidylist.cpp Implementation of AISubsidyList. */ + +#include "ai_subsidylist.hpp" +#include "ai_subsidy.hpp" +#include "../../economy_func.h" + +AISubsidyList::AISubsidyList() +{ + for (uint i = 0; i < lengthof(_subsidies); i++) { + if (AISubsidy::IsValidSubsidy(i)) this->AddItem(i); + } +} diff --git a/src/ai/api/ai_subsidylist.hpp b/src/ai/api/ai_subsidylist.hpp new file mode 100644 index 000000000..dde3ba351 --- /dev/null +++ b/src/ai/api/ai_subsidylist.hpp @@ -0,0 +1,20 @@ +/* $Id$ */ + +/** @file ai_subsidylist.hpp List all the subsidies. */ + +#ifndef AI_SUBSIDYLIST_HPP +#define AI_SUBSIDYLIST_HPP + +#include "ai_abstractlist.hpp" + +/** + * Creates a list of all current subsidies. + * @ingroup AIList + */ +class AISubsidyList : public AIAbstractList { +public: + static const char *GetClassName() { return "AISubsidyList"; } + AISubsidyList(); +}; + +#endif /* AI_SUBSIDYLIST_HPP */ diff --git a/src/ai/api/ai_subsidylist.hpp.sq b/src/ai/api/ai_subsidylist.hpp.sq new file mode 100644 index 000000000..db86a6ab6 --- /dev/null +++ b/src/ai/api/ai_subsidylist.hpp.sq @@ -0,0 +1,23 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_subsidylist.hpp" + +namespace SQConvert { + /* Allow AISubsidyList to be used as Squirrel parameter */ + template <> AISubsidyList *GetParam(ForceType<AISubsidyList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AISubsidyList *)instance; } + template <> AISubsidyList &GetParam(ForceType<AISubsidyList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AISubsidyList *)instance; } + template <> const AISubsidyList *GetParam(ForceType<const AISubsidyList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AISubsidyList *)instance; } + template <> const AISubsidyList &GetParam(ForceType<const AISubsidyList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AISubsidyList *)instance; } + template <> int Return<AISubsidyList *>(HSQUIRRELVM vm, AISubsidyList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AISubsidyList", res, NULL, DefSQDestructorCallback<AISubsidyList>); return 1; } +}; // namespace SQConvert + +void SQAISubsidyList_Register(Squirrel *engine) { + DefSQClass <AISubsidyList> SQAISubsidyList("AISubsidyList"); + SQAISubsidyList.PreRegister(engine, "AIAbstractList"); + SQAISubsidyList.AddConstructor<void (AISubsidyList::*)(), 1>(engine, "x"); + + SQAISubsidyList.DefSQStaticMethod(engine, &AISubsidyList::GetClassName, "GetClassName", 1, "x"); + + SQAISubsidyList.PostRegister(engine); +} diff --git a/src/ai/api/ai_testmode.cpp b/src/ai/api/ai_testmode.cpp new file mode 100644 index 000000000..1b09fa699 --- /dev/null +++ b/src/ai/api/ai_testmode.cpp @@ -0,0 +1,26 @@ +/* $Id$ */ + +/** @file ai_testmode.cpp Implementation of AITestMode. */ + +#include "ai_testmode.hpp" +#include "../../command_type.h" + +bool AITestMode::ModeProc(TileIndex tile, uint32 p1, uint32 p2, uint procc, CommandCost costs) +{ + /* In test mode we only return 'false', telling the DoCommand it + * should stop after testing the command and return with that result. */ + return false; +} + +AITestMode::AITestMode() +{ + this->last_mode = this->GetDoCommandMode(); + this->last_instance = this->GetDoCommandModeInstance(); + this->SetDoCommandMode(&AITestMode::ModeProc, this); +} + +AITestMode::~AITestMode() +{ + assert(this->GetDoCommandModeInstance() == this); + this->SetDoCommandMode(this->last_mode, this->last_instance); +} diff --git a/src/ai/api/ai_testmode.hpp b/src/ai/api/ai_testmode.hpp new file mode 100644 index 000000000..c65c501d9 --- /dev/null +++ b/src/ai/api/ai_testmode.hpp @@ -0,0 +1,48 @@ +/* $Id$ */ + +/** @file ai_testmode.hpp Switch the AI to Test Mode. */ + +#ifndef AI_TESTMODE_HPP +#define AI_TESTMODE_HPP + +#include "ai_object.hpp" + +/** + * Class to switch current mode to Test Mode. + * If you create an instance of this class, the mode will be switched to + * Testing. The original mode is stored and recovered from when ever the + * instance is destroyed. + * In Test mode all the commands you execute aren't really executed. The + * system only checks if it would be able to execute your requests, and what + * the cost would be. + */ +class AITestMode : public AIObject { +public: + static const char *GetClassName() { return "AITestMode"; } + +private: + AIModeProc *last_mode; + AIObject *last_instance; + +protected: + /** + * The callback proc for Testing mode. + */ + static bool ModeProc(TileIndex tile, uint32 p1, uint32 p2, uint procc, CommandCost costs); + +public: + /** + * Creating instance of this class switches the build mode to Testing. + * @note When the instance is destroyed, he restores the mode that was + * current when the instance was created! + */ + AITestMode(); + + /** + * Destroying this instance reset the building mode to the mode it was + * in when the instance was created. + */ + ~AITestMode(); +}; + +#endif /* AI_TESTMODE_HPP */ diff --git a/src/ai/api/ai_testmode.hpp.sq b/src/ai/api/ai_testmode.hpp.sq new file mode 100644 index 000000000..5343d8cab --- /dev/null +++ b/src/ai/api/ai_testmode.hpp.sq @@ -0,0 +1,23 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_testmode.hpp" + +namespace SQConvert { + /* Allow AITestMode to be used as Squirrel parameter */ + template <> AITestMode *GetParam(ForceType<AITestMode *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITestMode *)instance; } + template <> AITestMode &GetParam(ForceType<AITestMode &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITestMode *)instance; } + template <> const AITestMode *GetParam(ForceType<const AITestMode *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITestMode *)instance; } + template <> const AITestMode &GetParam(ForceType<const AITestMode &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITestMode *)instance; } + template <> int Return<AITestMode *>(HSQUIRRELVM vm, AITestMode *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITestMode", res, NULL, DefSQDestructorCallback<AITestMode>); return 1; } +}; // namespace SQConvert + +void SQAITestMode_Register(Squirrel *engine) { + DefSQClass <AITestMode> SQAITestMode("AITestMode"); + SQAITestMode.PreRegister(engine); + SQAITestMode.AddConstructor<void (AITestMode::*)(), 1>(engine, "x"); + + SQAITestMode.DefSQStaticMethod(engine, &AITestMode::GetClassName, "GetClassName", 1, "x"); + + SQAITestMode.PostRegister(engine); +} diff --git a/src/ai/api/ai_tile.cpp b/src/ai/api/ai_tile.cpp new file mode 100644 index 000000000..868cc679a --- /dev/null +++ b/src/ai/api/ai_tile.cpp @@ -0,0 +1,239 @@ +/* $Id$ */ + +/** @file ai_tile.cpp Implementation of AITile. */ + +#include "ai_tile.hpp" +#include "ai_map.hpp" +#include "ai_town.hpp" +#include "../../openttd.h" +#include "../../tile_map.h" +#include "../../tile_cmd.h" +#include "../../map_func.h" +#include "../../variables.h" +#include "../../station_func.h" +#include "../../command_type.h" +#include "../../settings_type.h" +#include "../../company_func.h" +#include "../../road_map.h" +#include "../../water_map.h" +#include "../../clear_map.h" +#include "../../town.h" + +/* static */ bool AITile::IsBuildable(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + switch (::GetTileType(tile)) { + default: return false; + case MP_CLEAR: return true; + case MP_TREES: return true; + case MP_WATER: return IsCoast(tile); + case MP_ROAD: + /* Tram bits aren't considered buildable */ + if (::GetRoadTypes(tile) != ROADTYPES_ROAD) return false; + /* Depots and crossings aren't considered buildable */ + if (::GetRoadTileType(tile) != ROAD_TILE_NORMAL) return false; + if (CountBits(::GetRoadBits(tile, ROADTYPE_ROAD)) != 1) return false; + if (::IsRoadOwner(tile, ROADTYPE_ROAD, OWNER_TOWN)) return true; + if (::IsRoadOwner(tile, ROADTYPE_ROAD, _current_company)) return true; + return false; + } +} + +/* static */ bool AITile::IsBuildableRectangle(TileIndex tile, uint width, uint height) +{ + uint tx, ty; + + tx = AIMap::GetTileX(tile); + ty = AIMap::GetTileY(tile); + + for (uint x = tx; x < width + tx; x++) { + for (uint y = ty; y < height + ty; y++) { + if (!IsBuildable(AIMap::GetTileIndex(x, y))) return false; + } + } + + return true; +} + +/* static */ bool AITile::IsWaterTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_WATER) && !::IsCoast(tile); +} + +/* static */ bool AITile::IsCoastTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_WATER) && ::IsCoast(tile); +} + +/* static */ bool AITile::IsStationTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::IsTileType(tile, MP_STATION); +} + +/* static */ bool AITile::IsSteepSlope(Slope slope) +{ + if (slope == SLOPE_INVALID) return false; + + return ::IsSteepSlope((::Slope)slope); +} + +/* static */ bool AITile::IsHalftileSlope(Slope slope) +{ + if (slope == SLOPE_INVALID) return false; + + return ::IsHalftileSlope((::Slope)slope); +} + +/* static */ bool AITile::HasTreeOnTile(TileIndex tile) +{ + return ::IsTileType(tile, MP_TREES); +} + +/* static */ bool AITile::IsFarmTile(TileIndex tile) +{ + return (::IsTileType(tile, MP_CLEAR) && ::IsClearGround(tile, CLEAR_FIELDS)); +} + +/* static */ bool AITile::IsRockTile(TileIndex tile) +{ + return (::IsTileType(tile, MP_CLEAR) && ::IsClearGround(tile, CLEAR_ROCKS)); +} + +/* static */ bool AITile::IsRoughTile(TileIndex tile) +{ + return (::IsTileType(tile, MP_CLEAR) && ::IsClearGround(tile, CLEAR_ROUGH)); +} + +/* static */ bool AITile::IsSnowTile(TileIndex tile) +{ + return (::IsTileType(tile, MP_CLEAR) && ::IsClearGround(tile, CLEAR_SNOW)); +} + +/* static */ bool AITile::IsDesertTile(TileIndex tile) +{ + return (::IsTileType(tile, MP_CLEAR) && ::IsClearGround(tile, CLEAR_DESERT)); +} + +/* static */ AITile::Slope AITile::GetSlope(TileIndex tile) +{ + if (!::IsValidTile(tile)) return SLOPE_INVALID; + + return (Slope)::GetTileSlope(tile, NULL); +} + +/* static */ AITile::Slope AITile::GetComplementSlope(Slope slope) +{ + if (slope == SLOPE_INVALID) return SLOPE_INVALID; + if (IsSteepSlope(slope)) return SLOPE_INVALID; + if (IsHalftileSlope(slope)) return SLOPE_INVALID; + + return (Slope)::ComplementSlope((::Slope)slope); +} + +/* static */ int32 AITile::GetHeight(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + + return ::TileHeight(tile); +} + +/* static */ AICompany::CompanyID AITile::GetOwner(TileIndex tile) +{ + if (!::IsValidTile(tile)) return AICompany::INVALID_COMPANY; + if (::IsTileType(tile, MP_HOUSE)) return AICompany::INVALID_COMPANY; + if (::IsTileType(tile, MP_INDUSTRY)) return AICompany::INVALID_COMPANY; + + return AICompany::ResolveCompanyID((AICompany::CompanyID)(byte)::GetTileOwner(tile)); +} + +/* static */ bool AITile::HasTransportType(TileIndex tile, TransportType transport_type) +{ + if (!::IsValidTile(tile)) return false; + + return GB(::GetTileTrackStatus(tile, (::TransportType)transport_type, UINT32_MAX), 0, 16) != 0; +} + +/* static */ int32 AITile::GetCargoAcceptance(TileIndex tile, CargoID cargo_type, uint width, uint height, uint radius) +{ + if (!::IsValidTile(tile)) return false; + + AcceptedCargo accepts; + ::GetAcceptanceAroundTiles(accepts, tile, width, height, _settings_game.station.modified_catchment ? radius : (uint)CA_UNMODIFIED); + return accepts[cargo_type]; +} + +/* static */ int32 AITile::GetCargoProduction(TileIndex tile, CargoID cargo_type, uint width, uint height, uint radius) +{ + if (!::IsValidTile(tile)) return false; + + AcceptedCargo produced; + ::GetProductionAroundTiles(produced, tile, width, height, _settings_game.station.modified_catchment ? radius : (uint)CA_UNMODIFIED); + return produced[cargo_type]; +} + +/* static */ int32 AITile::GetDistanceManhattanToTile(TileIndex tile_from, TileIndex tile_to) +{ + return AIMap::DistanceManhattan(tile_from, tile_to); +} + +/* static */ int32 AITile::GetDistanceSquareToTile(TileIndex tile_from, TileIndex tile_to) +{ + return AIMap::DistanceSquare(tile_from, tile_to); +} + +/* static */ bool AITile::RaiseTile(TileIndex tile, int32 slope) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + + return AIObject::DoCommand(tile, slope, 1, CMD_TERRAFORM_LAND); +} + +/* static */ bool AITile::LowerTile(TileIndex tile, int32 slope) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + + return AIObject::DoCommand(tile, slope, 0, CMD_TERRAFORM_LAND); +} + +/* static */ bool AITile::DemolishTile(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR); +} + +/* static */ bool AITile::PlantTree(TileIndex tile) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + + return AIObject::DoCommand(tile, -1, tile, CMD_PLANT_TREE); +} + +/* static */ bool AITile::PlantTreeRectangle(TileIndex tile, uint width, uint height) +{ + EnforcePrecondition(false, ::IsValidTile(tile)); + EnforcePrecondition(false, width >= 1 && width <= 20); + EnforcePrecondition(false, height >= 1 && height <= 20); + TileIndex end_tile = tile + ::TileDiffXY(width - 1, height - 1); + + return AIObject::DoCommand(tile, -1, end_tile, CMD_PLANT_TREE); +} + +/* static */ bool AITile::IsWithinTownInfluence(TileIndex tile, TownID town_id) +{ + return AITown::IsWithinTownInfluence(town_id, tile); +} + +/* static */ TownID AITile::GetClosestTown(TileIndex tile) +{ + if (!::IsValidTile(tile)) return INVALID_TOWN; + + return ::ClosestTownFromTile(tile, UINT_MAX)->index; +} diff --git a/src/ai/api/ai_tile.hpp b/src/ai/api/ai_tile.hpp new file mode 100644 index 000000000..298de75cb --- /dev/null +++ b/src/ai/api/ai_tile.hpp @@ -0,0 +1,362 @@ +/* $Id$ */ + +/** @file ai_tile.hpp Everything to query and manipulate tiles. */ + +#ifndef AI_TILE_HPP +#define AI_TILE_HPP + +#include "ai_abstractlist.hpp" +#include "ai_error.hpp" +#include "ai_company.hpp" + +/** + * Class that handles all tile related functions. + */ +class AITile : public AIObject { +public: + static const char *GetClassName() { return "AITile"; } + + /** + * Error messages related to modifying tiles. + */ + enum ErrorMessages { + + /** Base for tile related errors */ + ERR_TILE_BASE = AIError::ERR_CAT_TILE << AIError::ERR_CAT_BIT_SIZE, + + /** Tile can't be raised any higher */ + ERR_TILE_TOO_HIGH, // [STR_1003_ALREADY_AT_SEA_LEVEL] + + /** Tile can't be lowered any lower */ + ERR_TILE_TOO_LOW, // [STR_1003_ALREADY_AT_SEA_LEVEL] + }; + + /** + * Enumeration for the slope-type (from slopes.h). + * + * This enumeration use the chars N, E, S, W corresponding the + * direction North, East, South and West. The top corner of a tile + * is the north-part of the tile. + */ + enum Slope { + /* Values are important, as they represent the internal state of the game. */ + SLOPE_FLAT = 0x00, //!< A flat tile + SLOPE_W = 0x01, //!< The west corner of the tile is raised + SLOPE_S = 0x02, //!< The south corner of the tile is raised + SLOPE_E = 0x04, //!< The east corner of the tile is raised + SLOPE_N = 0x08, //!< The north corner of the tile is raised + SLOPE_STEEP = 0x10, //!< Indicates the slope is steep + SLOPE_NW = SLOPE_N | SLOPE_W, //!< North and west corner are raised + SLOPE_SW = SLOPE_S | SLOPE_W, //!< South and west corner are raised + SLOPE_SE = SLOPE_S | SLOPE_E, //!< South and east corner are raised + SLOPE_NE = SLOPE_N | SLOPE_E, //!< North and east corner are raised + SLOPE_EW = SLOPE_E | SLOPE_W, //!< East and west corner are raised + SLOPE_NS = SLOPE_N | SLOPE_S, //!< North and south corner are raised + SLOPE_ELEVATED = SLOPE_N | SLOPE_E | SLOPE_S | SLOPE_W, //!< All corner are raised, similar to SLOPE_FLAT + SLOPE_NWS = SLOPE_N | SLOPE_W | SLOPE_S, //!< North, west and south corner are raised + SLOPE_WSE = SLOPE_W | SLOPE_S | SLOPE_E, //!< West, south and east corner are raised + SLOPE_SEN = SLOPE_S | SLOPE_E | SLOPE_N, //!< South, east and north corner are raised + SLOPE_ENW = SLOPE_E | SLOPE_N | SLOPE_W, //!< East, north and west corner are raised + SLOPE_STEEP_W = SLOPE_STEEP | SLOPE_NWS, //!< A steep slope falling to east (from west) + SLOPE_STEEP_S = SLOPE_STEEP | SLOPE_WSE, //!< A steep slope falling to north (from south) + SLOPE_STEEP_E = SLOPE_STEEP | SLOPE_SEN, //!< A steep slope falling to west (from east) + SLOPE_STEEP_N = SLOPE_STEEP | SLOPE_ENW, //!< A steep slope falling to south (from north) + + SLOPE_INVALID = 0xFF, //!< An invalid slope + }; + + /** + * The different transport types a tile can have. + */ + enum TransportType { + /* Values are important, as they represent the internal state of the game. */ + TRANSPORT_RAIL = 0, //!< Tile with rail. + TRANSPORT_ROAD = 1, //!< Tile with road. + TRANSPORT_WATER = 2, //!< Tile with navigable waterways. + TRANSPORT_AIR = 3, //!< Tile with airport. + + INVALID_TRANSPORT = -1, //!< Tile without any transport type. + }; + + /** + * Check if this tile is buildable, i.e. no things on it that needs + * demolishing. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return True if it is buildable, false if not. + * @note For trams you also might want to check for AIRoad::IsRoad(), + * as you can build tram-rails on road-tiles. + * @note For rail you also might want to check for AIRoad::IsRoad(), + * as in some cases you can build rails on road-tiles. + */ + static bool IsBuildable(TileIndex tile); + + /** + * Check if this tile is buildable in a rectangle around a tile, with the + * entry in the list as top-left. + * @param tile The tile to check on. + * @param width The width of the rectangle. + * @param height The height of the rectangle. + * @pre AIMap::IsValidTile(tile). + * @return True if it is buildable, false if not. + */ + static bool IsBuildableRectangle(TileIndex tile, uint width, uint height); + + /** + * Checks whether the given tile is actually a water tile. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile is a water tile. + */ + static bool IsWaterTile(TileIndex tile); + + /** + * Checks whether the given tile is actually a coast tile. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile is a coast tile. + * @note Building on coast tiles in general is more expensive. + */ + static bool IsCoastTile(TileIndex tile); + + /** + * Checks whether the given tile is a station tile of any station. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile is a station tile. + */ + static bool IsStationTile(TileIndex tile); + + /** + * Check if a tile has a steep slope. + * @param slope The slope to check on. + * @pre slope != SLOPE_INVALID. + * @return True if the slope is a steep slope. + */ + static bool IsSteepSlope(Slope slope); + + /** + * Check if a tile has a halftile slope. + * @param slope The slope to check on. + * @pre slope != SLOPE_INVALID. + * @return True if the slope is a halftile slope. + */ + static bool IsHalftileSlope(Slope slope); + + /** + * Check if the tile has any tree on it. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if there is a tree on the tile. + */ + static bool HasTreeOnTile(TileIndex tile); + + /** + * Check if the tile is a farmland tile. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile is farmland. + */ + static bool IsFarmTile(TileIndex tile); + + /** + * Check if the tile is a rock tile. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile is rock tile. + */ + static bool IsRockTile(TileIndex tile); + + /** + * Check if the tile is a rough tile. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile is rough tile. + */ + static bool IsRoughTile(TileIndex tile); + + /** + * Check if the tile is a snow tile. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile is snow tile. + */ + static bool IsSnowTile(TileIndex tile); + + /** + * Check if the tile is a desert tile. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile is desert tile. + */ + static bool IsDesertTile(TileIndex tile); + + /** + * Get the slope of a tile. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return 0 means flat, others indicate internal state of slope. + */ + static Slope GetSlope(TileIndex tile); + + /** + * Get the complement of the slope. + * @param slope The slope to get the complement of. + * @pre slope != SLOPE_INVALID. + * @pre !IsSteepSlope(slope). + * @pre !IsHalftileSlope(slope). + * @return The complement of a slope. This means that all corners that + * weren't raised, are raised, and visa versa. + */ + static Slope GetComplementSlope(Slope slope); + + /** + * Get the height of the tile. + * @param tile The tile to check on. + * @pre AIMap::IsValidTile(tile). + * @return The height of the tile, ranging from 0 to 15. + */ + static int32 GetHeight(TileIndex tile); + + /** + * Get the owner of the tile. + * @param tile The tile to get the owner from. + * @pre AIMap::IsValidTile(tile). + * @return The CompanyID of the owner of the tile, or INVALID_COMPANY if + * there is no owner (grass/industry/water tiles, etc.). + */ + static AICompany::CompanyID GetOwner(TileIndex tile); + + /** + * Checks whether the given tile contains parts suitable for the given + * TransportType. + * @param tile The tile to check. + * @param transport_type The TransportType to check against. + * @pre AIMap::IsValidTile(tile). + * @note Returns false on tiles with roadworks and on road tiles with only + * a single piece of road as these tiles cannot be used to transport + * anything on. It furthermore returns true on some coast tile for + * TRANSPORT_WATER because ships can navigate over them. + * @return True if and only if the tile has the given TransportType. + */ + static bool HasTransportType(TileIndex tile, TransportType transport_type); + + /** + * Check how much cargo this tile accepts. + * It creates a radius around the tile, and adds up all acceptance of this + * cargo. + * @param tile The tile to check on. + * @param cargo_type The cargo to check the acceptance of. + * @param width The width of the station. + * @param height The height of the station. + * @param radius The radius of the station. + * @pre AIMap::IsValidTile(tile). + * @return Value below 8 means no acceptance; the more the better. + */ + static int32 GetCargoAcceptance(TileIndex tile, CargoID cargo_type, uint width, uint height, uint radius); + + /** + * Checks how many tiles in the radius produces this cargo. + * It creates a radius around the tile, and adds up all tiles that produce + * this cargo. + * @param tile The tile to check on. + * @param cargo_type The cargo to check the production of. + * @param width The width of the station. + * @param height The height of the station. + * @param radius The radius of the station. + * @pre AIMap::IsValidTile(tile). + * @return The tiles that produce this cargo within radius of the tile. + * @note Town(houses) are not included in the value. + */ + static int32 GetCargoProduction(TileIndex tile, CargoID cargo_type, uint width, uint height, uint radius); + + /** + * Get the manhattan distance from the tile to the tile. + * @param tile_from The tile to get the distance to. + * @param tile_to The tile to get the distance to. + * @return The distance between the two tiles. + */ + static int32 GetDistanceManhattanToTile(TileIndex tile_from, TileIndex tile_to); + + /** + * Get the square distance from the tile to the tile. + * @param tile_from The tile to get the distance to. + * @param tile_to The tile to get the distance to. + * @return The distance between the two tiles. + */ + static int32 GetDistanceSquareToTile(TileIndex tile_from, TileIndex tile_to); + + /** + * Raise the given corners of the tile. The corners can be combined, + * for example: SLOPE_N | SLOPE_W (= SLOPE_NW) + * @param tile The tile to raise. + * @param slope Corners to raise (SLOPE_xxx). + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_TOO_CLOSE_TO_EDGE + * @exception AITile::ERR_TILE_TOO_HIGH + * @return 0 means failed, 1 means success. + */ + static bool RaiseTile(TileIndex tile, int32 slope); + + /** + * Lower the given corners of the tile. The corners can be combined, + * for example: SLOPE_N | SLOPE_W (= SLOPE_NW) + * @param tile The tile to lower. + * @param slope Corners to lower (SLOPE_xxx). + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AIError::ERR_TOO_CLOSE_TO_EDGE + * @exception AITile::ERR_TILE_TOO_LOW + * @return 0 means failed, 1 means success. + */ + static bool LowerTile(TileIndex tile, int32 slope); + + /** + * Destroy everything on the given tile. + * @param tile The tile to demolish. + * @pre AIMap::IsValidTile(tile). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @return True if and only if the tile was demolished. + */ + static bool DemolishTile(TileIndex tile); + + /** + * Create a random tree on a tile. + * @param tile The tile to build a tree on. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if a tree was added on the tile. + */ + static bool PlantTree(TileIndex tile); + + /** + * Create a random tree on a rectangle of tiles. + * @param tile The top left tile of the rectangle. + * @param width The width of the rectangle. + * @param height The height of the rectangle. + * @pre AIMap::IsValidTile(tile). + * @pre width >= 1 && width <= 20. + * @pre height >= 1 && height <= 20. + * @return True if and only if a tree was added on any of the tiles in the rectangle. + */ + static bool PlantTreeRectangle(TileIndex tile, uint width, uint height); + + /** + * Find out if this tile is within the rating influence of a town. + * Stations on this tile influence the rating of the town. + * @param tile The tile to check. + * @param town_id The town to check. + * @return True if the tile is within the rating influence of the town. + */ + static bool IsWithinTownInfluence(TileIndex tile, TownID town_id); + + /** + * Find the town that is closest to a tile. Stations you build at this tile + * will belong to this town. + * @param tile The tile to check. + * @return The TownID of the town closest to the tile. + */ + static TownID GetClosestTown(TileIndex tile); +}; + +#endif /* AI_TILE_HPP */ diff --git a/src/ai/api/ai_tile.hpp.sq b/src/ai/api/ai_tile.hpp.sq new file mode 100644 index 000000000..920dc6543 --- /dev/null +++ b/src/ai/api/ai_tile.hpp.sq @@ -0,0 +1,97 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_tile.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AITile::ErrorMessages GetParam(ForceType<AITile::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AITile::ErrorMessages)tmp; } + template <> int Return<AITile::ErrorMessages>(HSQUIRRELVM vm, AITile::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AITile::Slope GetParam(ForceType<AITile::Slope>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AITile::Slope)tmp; } + template <> int Return<AITile::Slope>(HSQUIRRELVM vm, AITile::Slope res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AITile::TransportType GetParam(ForceType<AITile::TransportType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AITile::TransportType)tmp; } + template <> int Return<AITile::TransportType>(HSQUIRRELVM vm, AITile::TransportType res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AITile to be used as Squirrel parameter */ + template <> AITile *GetParam(ForceType<AITile *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITile *)instance; } + template <> AITile &GetParam(ForceType<AITile &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITile *)instance; } + template <> const AITile *GetParam(ForceType<const AITile *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITile *)instance; } + template <> const AITile &GetParam(ForceType<const AITile &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITile *)instance; } + template <> int Return<AITile *>(HSQUIRRELVM vm, AITile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITile", res, NULL, DefSQDestructorCallback<AITile>); return 1; } +}; // namespace SQConvert + +void SQAITile_Register(Squirrel *engine) { + DefSQClass <AITile> SQAITile("AITile"); + SQAITile.PreRegister(engine); + SQAITile.AddConstructor<void (AITile::*)(), 1>(engine, "x"); + + SQAITile.DefSQConst(engine, AITile::ERR_TILE_BASE, "ERR_TILE_BASE"); + SQAITile.DefSQConst(engine, AITile::ERR_TILE_TOO_HIGH, "ERR_TILE_TOO_HIGH"); + SQAITile.DefSQConst(engine, AITile::ERR_TILE_TOO_LOW, "ERR_TILE_TOO_LOW"); + SQAITile.DefSQConst(engine, AITile::SLOPE_FLAT, "SLOPE_FLAT"); + SQAITile.DefSQConst(engine, AITile::SLOPE_W, "SLOPE_W"); + SQAITile.DefSQConst(engine, AITile::SLOPE_S, "SLOPE_S"); + SQAITile.DefSQConst(engine, AITile::SLOPE_E, "SLOPE_E"); + SQAITile.DefSQConst(engine, AITile::SLOPE_N, "SLOPE_N"); + SQAITile.DefSQConst(engine, AITile::SLOPE_STEEP, "SLOPE_STEEP"); + SQAITile.DefSQConst(engine, AITile::SLOPE_NW, "SLOPE_NW"); + SQAITile.DefSQConst(engine, AITile::SLOPE_SW, "SLOPE_SW"); + SQAITile.DefSQConst(engine, AITile::SLOPE_SE, "SLOPE_SE"); + SQAITile.DefSQConst(engine, AITile::SLOPE_NE, "SLOPE_NE"); + SQAITile.DefSQConst(engine, AITile::SLOPE_EW, "SLOPE_EW"); + SQAITile.DefSQConst(engine, AITile::SLOPE_NS, "SLOPE_NS"); + SQAITile.DefSQConst(engine, AITile::SLOPE_ELEVATED, "SLOPE_ELEVATED"); + SQAITile.DefSQConst(engine, AITile::SLOPE_NWS, "SLOPE_NWS"); + SQAITile.DefSQConst(engine, AITile::SLOPE_WSE, "SLOPE_WSE"); + SQAITile.DefSQConst(engine, AITile::SLOPE_SEN, "SLOPE_SEN"); + SQAITile.DefSQConst(engine, AITile::SLOPE_ENW, "SLOPE_ENW"); + SQAITile.DefSQConst(engine, AITile::SLOPE_STEEP_W, "SLOPE_STEEP_W"); + SQAITile.DefSQConst(engine, AITile::SLOPE_STEEP_S, "SLOPE_STEEP_S"); + SQAITile.DefSQConst(engine, AITile::SLOPE_STEEP_E, "SLOPE_STEEP_E"); + SQAITile.DefSQConst(engine, AITile::SLOPE_STEEP_N, "SLOPE_STEEP_N"); + SQAITile.DefSQConst(engine, AITile::SLOPE_INVALID, "SLOPE_INVALID"); + SQAITile.DefSQConst(engine, AITile::TRANSPORT_RAIL, "TRANSPORT_RAIL"); + SQAITile.DefSQConst(engine, AITile::TRANSPORT_ROAD, "TRANSPORT_ROAD"); + SQAITile.DefSQConst(engine, AITile::TRANSPORT_WATER, "TRANSPORT_WATER"); + SQAITile.DefSQConst(engine, AITile::TRANSPORT_AIR, "TRANSPORT_AIR"); + SQAITile.DefSQConst(engine, AITile::INVALID_TRANSPORT, "INVALID_TRANSPORT"); + + AIError::RegisterErrorMap(STR_1003_ALREADY_AT_SEA_LEVEL, AITile::ERR_TILE_TOO_HIGH); + AIError::RegisterErrorMap(STR_1003_ALREADY_AT_SEA_LEVEL, AITile::ERR_TILE_TOO_LOW); + + AIError::RegisterErrorMapString(AITile::ERR_TILE_TOO_HIGH, "ERR_TILE_TOO_HIGH"); + AIError::RegisterErrorMapString(AITile::ERR_TILE_TOO_LOW, "ERR_TILE_TOO_LOW"); + + SQAITile.DefSQStaticMethod(engine, &AITile::GetClassName, "GetClassName", 1, "x"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsBuildable, "IsBuildable", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsBuildableRectangle, "IsBuildableRectangle", 4, "xiii"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsWaterTile, "IsWaterTile", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsCoastTile, "IsCoastTile", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsStationTile, "IsStationTile", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsSteepSlope, "IsSteepSlope", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsHalftileSlope, "IsHalftileSlope", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::HasTreeOnTile, "HasTreeOnTile", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsFarmTile, "IsFarmTile", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsRockTile, "IsRockTile", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsRoughTile, "IsRoughTile", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsSnowTile, "IsSnowTile", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsDesertTile, "IsDesertTile", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::GetSlope, "GetSlope", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::GetComplementSlope, "GetComplementSlope", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::GetHeight, "GetHeight", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::GetOwner, "GetOwner", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::HasTransportType, "HasTransportType", 3, "xii"); + SQAITile.DefSQStaticMethod(engine, &AITile::GetCargoAcceptance, "GetCargoAcceptance", 6, "xiiiii"); + SQAITile.DefSQStaticMethod(engine, &AITile::GetCargoProduction, "GetCargoProduction", 6, "xiiiii"); + SQAITile.DefSQStaticMethod(engine, &AITile::GetDistanceManhattanToTile, "GetDistanceManhattanToTile", 3, "xii"); + SQAITile.DefSQStaticMethod(engine, &AITile::GetDistanceSquareToTile, "GetDistanceSquareToTile", 3, "xii"); + SQAITile.DefSQStaticMethod(engine, &AITile::RaiseTile, "RaiseTile", 3, "xii"); + SQAITile.DefSQStaticMethod(engine, &AITile::LowerTile, "LowerTile", 3, "xii"); + SQAITile.DefSQStaticMethod(engine, &AITile::DemolishTile, "DemolishTile", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::PlantTree, "PlantTree", 2, "xi"); + SQAITile.DefSQStaticMethod(engine, &AITile::PlantTreeRectangle, "PlantTreeRectangle", 4, "xiii"); + SQAITile.DefSQStaticMethod(engine, &AITile::IsWithinTownInfluence, "IsWithinTownInfluence", 3, "xii"); + SQAITile.DefSQStaticMethod(engine, &AITile::GetClosestTown, "GetClosestTown", 2, "xi"); + + SQAITile.PostRegister(engine); +} diff --git a/src/ai/api/ai_tilelist.cpp b/src/ai/api/ai_tilelist.cpp new file mode 100644 index 000000000..24575c697 --- /dev/null +++ b/src/ai/api/ai_tilelist.cpp @@ -0,0 +1,175 @@ +/* $Id$ */ + +/** @file ai_tilelist.cpp Implementation of AITileList and friends. */ + +#include "ai_tilelist.hpp" +#include "ai_industry.hpp" +#include "../../openttd.h" +#include "../../landscape.h" +#include "../../settings_type.h" +#include "../../station_func.h" +#include "../../map_func.h" +#include "../../tile_map.h" +#include "../../industry_map.h" +#include "../../station_base.h" +#include "../../station_map.h" + +void AITileList::FixRectangleSpan(TileIndex &t1, TileIndex &t2) +{ + uint x1 = ::TileX(t1); + uint x2 = ::TileX(t2); + + uint y1 = ::TileY(t1); + uint y2 = ::TileY(t2); + + if (x1 >= x2) ::Swap(x1, x2); + if (y1 >= y2) ::Swap(y1, y2); + + t1 = ::TileXY(x1, y1); + t2 = ::TileXY(x2, y2); +} + +void AITileList::AddRectangle(TileIndex t1, TileIndex t2) +{ + if (!::IsValidTile(t1)) return; + if (!::IsValidTile(t2)) return; + + this->FixRectangleSpan(t1, t2); + + uint w = TileX(t2) - TileX(t1) + 1; + uint h = TileY(t2) - TileY(t1) + 1; + + BEGIN_TILE_LOOP(t, w, h, t1) { + this->AddItem(t); + } END_TILE_LOOP(t, w, h, t1) +} + +void AITileList::AddTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return; + + this->AddItem(tile); +} + +void AITileList::RemoveRectangle(TileIndex t1, TileIndex t2) +{ + if (!::IsValidTile(t1)) return; + if (!::IsValidTile(t2)) return; + + this->FixRectangleSpan(t1, t2); + + uint w = TileX(t2) - TileX(t1) + 1; + uint h = TileY(t2) - TileY(t1) + 1; + + BEGIN_TILE_LOOP(t, w, h, t1) { + this->RemoveItem(t); + } END_TILE_LOOP(t, w, h, t1) +} + +void AITileList::RemoveTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return; + + this->RemoveItem(tile); +} + +AITileList_IndustryAccepting::AITileList_IndustryAccepting(IndustryID industry_id, uint radius) +{ + if (!AIIndustry::IsValidIndustry(industry_id)) return; + + const Industry *i = ::GetIndustry(industry_id); + const IndustrySpec *indsp = ::GetIndustrySpec(i->type); + + /* Check if this industry accepts anything */ + { + bool cargo_accepts = false; + for (byte j = 0; j < lengthof(indsp->accepts_cargo); j++) { + if (indsp->accepts_cargo[j] != CT_INVALID) cargo_accepts = true; + } + if (!cargo_accepts) return; + } + + if (!_settings_game.station.modified_catchment) radius = CA_UNMODIFIED; + + BEGIN_TILE_LOOP(cur_tile, i->width + radius * 2, i->height + radius * 2, i->xy - ::TileDiffXY(radius, radius)) { + if (!::IsValidTile(cur_tile)) continue; + /* Exclude all tiles that belong to this industry */ + if (::IsTileType(cur_tile, MP_INDUSTRY) && ::GetIndustryIndex(cur_tile) == industry_id) continue; + + /* Only add the tile if it accepts the cargo (sometimes just 1 tile of an + * industry triggers the acceptance). */ + AcceptedCargo accepts; + ::GetAcceptanceAroundTiles(accepts, cur_tile, 1, 1, radius); + { + bool cargo_accepts = false; + for (byte j = 0; j < lengthof(indsp->accepts_cargo); j++) { + if (indsp->accepts_cargo[j] != CT_INVALID && accepts[indsp->accepts_cargo[j]] != 0) cargo_accepts = true; + } + if (!cargo_accepts) continue; + } + + this->AddTile(cur_tile); + } END_TILE_LOOP(cur_tile, i->width + radius * 2, i->height + radius * 2, i->xy - ::TileDiffXY(radius, radius)) +} + +AITileList_IndustryProducing::AITileList_IndustryProducing(IndustryID industry_id, uint radius) +{ + if (!AIIndustry::IsValidIndustry(industry_id)) return; + + const Industry *i = ::GetIndustry(industry_id); + const IndustrySpec *indsp = ::GetIndustrySpec(i->type); + + /* Check if this industry produces anything */ + { + bool cargo_produces = false; + for (byte j = 0; j < lengthof(indsp->produced_cargo); j++) { + if (indsp->produced_cargo[j] != CT_INVALID) cargo_produces = true; + } + if (!cargo_produces) return; + } + + if (!_settings_game.station.modified_catchment) radius = CA_UNMODIFIED; + + BEGIN_TILE_LOOP(cur_tile, i->width + radius * 2, i->height + radius * 2, i->xy - ::TileDiffXY(radius, radius)) { + if (!::IsValidTile(cur_tile)) continue; + /* Exclude all tiles that belong to this industry */ + if (::IsTileType(cur_tile, MP_INDUSTRY) && ::GetIndustryIndex(cur_tile) == industry_id) continue; + + /* Only add the tile if it produces the cargo (a bug in OpenTTD makes this + * inconsitance). */ + AcceptedCargo produces; + ::GetProductionAroundTiles(produces, cur_tile, 1, 1, radius); + { + bool cargo_produces = false; + for (byte j = 0; j < lengthof(indsp->produced_cargo); j++) { + if (indsp->produced_cargo[j] != CT_INVALID && produces[indsp->produced_cargo[j]] != 0) cargo_produces = true; + } + if (!cargo_produces) continue; + } + + this->AddTile(cur_tile); + } END_TILE_LOOP(cur_tile, i->width + radius * 2, i->height + radius * 2, i->xy - ::TileDiffXY(radius, radius)) +} + +AITileList_StationType::AITileList_StationType(StationID station_id, AIStation::StationType station_type) +{ + if (!AIStation::IsValidStation(station_id)) return; + + const StationRect *rect = &::GetStation(station_id)->rect; + + uint station_type_value = 0; + /* Convert AIStation::StationType to ::StationType, but do it in a + * bitmask, so we can scan for multiple entries at the same time. */ + if ((station_type & AIStation::STATION_TRAIN) != 0) station_type_value |= (1 << ::STATION_RAIL); + if ((station_type & AIStation::STATION_TRUCK_STOP) != 0) station_type_value |= (1 << ::STATION_TRUCK); + if ((station_type & AIStation::STATION_BUS_STOP) != 0) station_type_value |= (1 << ::STATION_BUS); + if ((station_type & AIStation::STATION_AIRPORT) != 0) station_type_value |= (1 << ::STATION_AIRPORT) | (1 << ::STATION_OILRIG); + if ((station_type & AIStation::STATION_DOCK) != 0) station_type_value |= (1 << ::STATION_DOCK) | (1 << ::STATION_OILRIG); + + BEGIN_TILE_LOOP(cur_tile, rect->right - rect->left + 1, rect->bottom - rect->top + 1, ::TileXY(rect->left, rect->top)) { + if (!::IsTileType(cur_tile, MP_STATION)) continue; + if (::GetStationIndex(cur_tile) != station_id) continue; + if (!HasBit(station_type_value, ::GetStationType(cur_tile))) continue; + this->AddTile(cur_tile); + } END_TILE_LOOP(cur_tile, rect->right - rect->left + 1, rect->bottom - rect->top + 1, ::TileXY(rect->left, rect->top)) +} diff --git a/src/ai/api/ai_tilelist.hpp b/src/ai/api/ai_tilelist.hpp new file mode 100644 index 000000000..f3d2f658d --- /dev/null +++ b/src/ai/api/ai_tilelist.hpp @@ -0,0 +1,110 @@ +/* $Id$ */ + +/** @file ai_tilelist.hpp List tiles. */ + +#ifndef AI_TILELIST_HPP +#define AI_TILELIST_HPP + +#include "ai_abstractlist.hpp" +#include "ai_station.hpp" + +/** + * Creates an empty list, in which you can add tiles. + * @ingroup AIList + */ +class AITileList : public AIAbstractList { +public: + static const char *GetClassName() { return "AITileList"; } + +private: + /** + * Make sure t1.x is smaller than t2.x and t1.y is smaller than t2.y. + * They are swapped to ensure they are after calling this function. + * @param t1 one of the corners of the rectangle. + * @param t2 the other corner of the rectangle. + */ + void FixRectangleSpan(TileIndex &t1, TileIndex &t2); + +public: + /** + * Adds the rectangle between tile_from and tile_to to the to-be-evaluated tiles. + * @param tile_from One corner of the tiles to add. + * @param tile_to The other corner of the tiles to add. + * @pre AIMap::IsValidTile(tile_from). + * @pre AIMap::IsValidTile(tile_to). + */ + void AddRectangle(TileIndex tile_from, TileIndex tile_to); + + /** + * Add a tile to the to-be-evaluated tiles. + * @param tile The tile to add. + * @pre AIMap::IsValidTile(tile). + */ + void AddTile(TileIndex tile); + + /** + * Remove the tiles inside the rectangle between tile_from and tile_to form the list. + * @param tile_from One corner of the tiles to remove. + * @param tile_to The other corner of the files to remove. + * @pre AIMap::IsValidTile(tile_from). + * @pre AIMap::IsValidTile(tile_to). + */ + void RemoveRectangle(TileIndex tile_from, TileIndex tile_to); + + /** + * Remove a tile from the list. + * @param tile The tile to remove. + * @pre AIMap::IsValidTile(tile). + */ + void RemoveTile(TileIndex tile); +}; + +/** + * Creates a list of tiles that will accept cargo for the given industry. + * @note If a simular industry is close, it might happen that this industry receives the cargo. + * @ingroup AIList + */ +class AITileList_IndustryAccepting : public AITileList { +public: + static const char *GetClassName() { return "AITileList_IndustryAccepting"; } + + /** + * @param industry_id The industry to create the AITileList around. + * @param radius The radius of the station you will be using. + */ + AITileList_IndustryAccepting(IndustryID industry_id, uint radius); +}; + +/** + * Creates a list of tiles which the industry checks to see if a station is + * there to receive cargo produced by this industry. + * @ingroup AIList + */ +class AITileList_IndustryProducing : public AITileList { +public: + static const char *GetClassName() { return "AITileList_IndustryProducing"; } + + /** + * @param industry_id The industry to create the AITileList around. + * @param radius The radius of the station you will be using. + */ + AITileList_IndustryProducing(IndustryID industry_id, uint radius); +}; + +/** + * Creates a list of tiles which have the requested StationType of the + * StationID. + * @ingroup AIList + */ +class AITileList_StationType : public AITileList { +public: + static const char *GetClassName() { return "AITileList_StationType"; } + + /** + * @param station_id The station to create the AITileList for. + * @param station_type The StationType to create the AIList for. + */ + AITileList_StationType(StationID station_id, AIStation::StationType station_type); +}; + +#endif /* AI_TILELIST_HPP */ diff --git a/src/ai/api/ai_tilelist.hpp.sq b/src/ai/api/ai_tilelist.hpp.sq new file mode 100644 index 000000000..4e6bfdf30 --- /dev/null +++ b/src/ai/api/ai_tilelist.hpp.sq @@ -0,0 +1,85 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_tilelist.hpp" + +namespace SQConvert { + /* Allow AITileList to be used as Squirrel parameter */ + template <> AITileList *GetParam(ForceType<AITileList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileList *)instance; } + template <> AITileList &GetParam(ForceType<AITileList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList *)instance; } + template <> const AITileList *GetParam(ForceType<const AITileList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileList *)instance; } + template <> const AITileList &GetParam(ForceType<const AITileList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList *)instance; } + template <> int Return<AITileList *>(HSQUIRRELVM vm, AITileList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList", res, NULL, DefSQDestructorCallback<AITileList>); return 1; } +}; // namespace SQConvert + +void SQAITileList_Register(Squirrel *engine) { + DefSQClass <AITileList> SQAITileList("AITileList"); + SQAITileList.PreRegister(engine, "AIAbstractList"); + SQAITileList.AddConstructor<void (AITileList::*)(), 1>(engine, "x"); + + SQAITileList.DefSQStaticMethod(engine, &AITileList::GetClassName, "GetClassName", 1, "x"); + + SQAITileList.DefSQMethod(engine, &AITileList::AddRectangle, "AddRectangle", 3, "xii"); + SQAITileList.DefSQMethod(engine, &AITileList::AddTile, "AddTile", 2, "xi"); + SQAITileList.DefSQMethod(engine, &AITileList::RemoveRectangle, "RemoveRectangle", 3, "xii"); + SQAITileList.DefSQMethod(engine, &AITileList::RemoveTile, "RemoveTile", 2, "xi"); + + SQAITileList.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AITileList_IndustryAccepting to be used as Squirrel parameter */ + template <> AITileList_IndustryAccepting *GetParam(ForceType<AITileList_IndustryAccepting *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileList_IndustryAccepting *)instance; } + template <> AITileList_IndustryAccepting &GetParam(ForceType<AITileList_IndustryAccepting &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_IndustryAccepting *)instance; } + template <> const AITileList_IndustryAccepting *GetParam(ForceType<const AITileList_IndustryAccepting *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileList_IndustryAccepting *)instance; } + template <> const AITileList_IndustryAccepting &GetParam(ForceType<const AITileList_IndustryAccepting &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_IndustryAccepting *)instance; } + template <> int Return<AITileList_IndustryAccepting *>(HSQUIRRELVM vm, AITileList_IndustryAccepting *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_IndustryAccepting", res, NULL, DefSQDestructorCallback<AITileList_IndustryAccepting>); return 1; } +}; // namespace SQConvert + +void SQAITileList_IndustryAccepting_Register(Squirrel *engine) { + DefSQClass <AITileList_IndustryAccepting> SQAITileList_IndustryAccepting("AITileList_IndustryAccepting"); + SQAITileList_IndustryAccepting.PreRegister(engine, "AITileList"); + SQAITileList_IndustryAccepting.AddConstructor<void (AITileList_IndustryAccepting::*)(IndustryID industry_id, uint radius), 3>(engine, "xii"); + + SQAITileList_IndustryAccepting.DefSQStaticMethod(engine, &AITileList_IndustryAccepting::GetClassName, "GetClassName", 1, "x"); + + SQAITileList_IndustryAccepting.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AITileList_IndustryProducing to be used as Squirrel parameter */ + template <> AITileList_IndustryProducing *GetParam(ForceType<AITileList_IndustryProducing *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileList_IndustryProducing *)instance; } + template <> AITileList_IndustryProducing &GetParam(ForceType<AITileList_IndustryProducing &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_IndustryProducing *)instance; } + template <> const AITileList_IndustryProducing *GetParam(ForceType<const AITileList_IndustryProducing *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileList_IndustryProducing *)instance; } + template <> const AITileList_IndustryProducing &GetParam(ForceType<const AITileList_IndustryProducing &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_IndustryProducing *)instance; } + template <> int Return<AITileList_IndustryProducing *>(HSQUIRRELVM vm, AITileList_IndustryProducing *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_IndustryProducing", res, NULL, DefSQDestructorCallback<AITileList_IndustryProducing>); return 1; } +}; // namespace SQConvert + +void SQAITileList_IndustryProducing_Register(Squirrel *engine) { + DefSQClass <AITileList_IndustryProducing> SQAITileList_IndustryProducing("AITileList_IndustryProducing"); + SQAITileList_IndustryProducing.PreRegister(engine, "AITileList"); + SQAITileList_IndustryProducing.AddConstructor<void (AITileList_IndustryProducing::*)(IndustryID industry_id, uint radius), 3>(engine, "xii"); + + SQAITileList_IndustryProducing.DefSQStaticMethod(engine, &AITileList_IndustryProducing::GetClassName, "GetClassName", 1, "x"); + + SQAITileList_IndustryProducing.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AITileList_StationType to be used as Squirrel parameter */ + template <> AITileList_StationType *GetParam(ForceType<AITileList_StationType *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileList_StationType *)instance; } + template <> AITileList_StationType &GetParam(ForceType<AITileList_StationType &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_StationType *)instance; } + template <> const AITileList_StationType *GetParam(ForceType<const AITileList_StationType *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileList_StationType *)instance; } + template <> const AITileList_StationType &GetParam(ForceType<const AITileList_StationType &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_StationType *)instance; } + template <> int Return<AITileList_StationType *>(HSQUIRRELVM vm, AITileList_StationType *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_StationType", res, NULL, DefSQDestructorCallback<AITileList_StationType>); return 1; } +}; // namespace SQConvert + +void SQAITileList_StationType_Register(Squirrel *engine) { + DefSQClass <AITileList_StationType> SQAITileList_StationType("AITileList_StationType"); + SQAITileList_StationType.PreRegister(engine, "AITileList"); + SQAITileList_StationType.AddConstructor<void (AITileList_StationType::*)(StationID station_id, AIStation::StationType station_type), 3>(engine, "xii"); + + SQAITileList_StationType.DefSQStaticMethod(engine, &AITileList_StationType::GetClassName, "GetClassName", 1, "x"); + + SQAITileList_StationType.PostRegister(engine); +} diff --git a/src/ai/api/ai_town.cpp b/src/ai/api/ai_town.cpp new file mode 100644 index 000000000..8c8ab9c02 --- /dev/null +++ b/src/ai/api/ai_town.cpp @@ -0,0 +1,197 @@ +/* $Id$ */ + +/** @file ai_town.cpp Implementation of AITown. */ + +#include "ai_town.hpp" +#include "ai_map.hpp" +#include "ai_cargo.hpp" +#include "ai_error.hpp" +#include "../../command_type.h" +#include "../../openttd.h" +#include "../../town.h" +#include "../../strings_func.h" +#include "../../core/alloc_func.hpp" +#include "../../company_func.h" +#include "../../station_base.h" +#include "table/strings.h" + +/* static */ TownID AITown::GetMaxTownID() +{ + return ::GetMaxTownIndex(); +} + +/* static */ int32 AITown::GetTownCount() +{ + return ::GetNumTowns(); +} + +/* static */ bool AITown::IsValidTown(TownID town_id) +{ + return ::IsValidTownID(town_id); +} + +/* static */ const char *AITown::GetName(TownID town_id) +{ + if (!IsValidTown(town_id)) return NULL; + static const int len = 64; + char *town_name = MallocT<char>(len); + + ::SetDParam(0, town_id); + ::GetString(town_name, STR_TOWN, &town_name[len - 1]); + + return town_name; +} + +/* static */ int32 AITown::GetPopulation(TownID town_id) +{ + if (!IsValidTown(town_id)) return -1; + const Town *t = ::GetTown(town_id); + return t->population; +} + +/* static */ int32 AITown::GetHouseCount(TownID town_id) +{ + if (!IsValidTown(town_id)) return -1; + const Town *t = ::GetTown(town_id); + return t->num_houses; +} + +/* static */ TileIndex AITown::GetLocation(TownID town_id) +{ + if (!IsValidTown(town_id)) return INVALID_TILE; + const Town *t = ::GetTown(town_id); + return t->xy; +} + +/* static */ int32 AITown::GetLastMonthProduction(TownID town_id, CargoID cargo_id) +{ + if (!IsValidTown(town_id)) return -1; + if (!AICargo::IsValidCargo(cargo_id)) return -1; + + const Town *t = ::GetTown(town_id); + + switch(AICargo::GetTownEffect(cargo_id)) { + case AICargo::TE_PASSENGERS: return t->act_pass; + case AICargo::TE_MAIL: return t->act_mail; + default: return -1; + } +} + +/* static */ int32 AITown::GetLastMonthTransported(TownID town_id, CargoID cargo_id) +{ + if (!IsValidTown(town_id)) return -1; + if (!AICargo::IsValidCargo(cargo_id)) return -1; + + const Town *t = ::GetTown(town_id); + + switch(AICargo::GetTownEffect(cargo_id)) { + case AICargo::TE_PASSENGERS: return t->pct_pass_transported; + case AICargo::TE_MAIL: return t->pct_mail_transported; + default: return -1; + } +} + +/* static */ int32 AITown::GetMaxProduction(TownID town_id, CargoID cargo_id) +{ + if (!IsValidTown(town_id)) return -1; + if (!AICargo::IsValidCargo(cargo_id)) return -1; + + const Town *t = ::GetTown(town_id); + + switch(AICargo::GetTownEffect(cargo_id)) { + case AICargo::TE_PASSENGERS: return t->max_pass; + case AICargo::TE_MAIL: return t->max_mail; + default: return -1; + } +} + +/* static */ int32 AITown::GetDistanceManhattanToTile(TownID town_id, TileIndex tile) +{ + return AIMap::DistanceManhattan(tile, GetLocation(town_id)); +} + +/* static */ int32 AITown::GetDistanceSquareToTile(TownID town_id, TileIndex tile) +{ + return AIMap::DistanceSquare(tile, GetLocation(town_id)); +} + +/* static */ bool AITown::IsWithinTownInfluence(TownID town_id, TileIndex tile) +{ + if (!IsValidTown(town_id)) return false; + + const Town *t = ::GetTown(town_id); + return ((uint32)GetDistanceSquareToTile(town_id, tile) <= t->squared_town_zone_radius[0]); +} + +/* static */ bool AITown::HasStatue(TownID town_id) +{ + if (!IsValidTown(town_id)) return false; + + return ::HasBit(::GetTown(town_id)->statues, _current_company); +} + +/* static */ int AITown::GetRoadReworkDuration(TownID town_id) +{ + if (!IsValidTown(town_id)) return -1; + + return ::GetTown(town_id)->road_build_months; +} + +/* static */ AICompany::CompanyID AITown::GetExclusiveRightsCompany(TownID town_id) +{ + if (!IsValidTown(town_id)) return AICompany::INVALID_COMPANY; + + return (AICompany::CompanyID)(int8)::GetTown(town_id)->exclusivity; +} + +/* static */ int32 AITown::GetExclusiveRightsDuration(TownID town_id) +{ + if (!IsValidTown(town_id)) return -1; + + return ::GetTown(town_id)->exclusive_counter; +} + +extern uint GetMaskOfTownActions(int *nump, CompanyID cid, const Town *t); + +/* static */ bool AITown::IsActionAvailable(TownID town_id, TownAction town_action) +{ + if (!IsValidTown(town_id)) return false; + + return HasBit(::GetMaskOfTownActions(NULL, _current_company, ::GetTown(town_id)), town_action); +} + +/* static */ bool AITown::PerformTownAction(TownID town_id, TownAction town_action) +{ + EnforcePrecondition(false, IsValidTown(town_id)); + EnforcePrecondition(false, IsActionAvailable(town_id, town_action)); + + return AIObject::DoCommand(::GetTown(town_id)->xy, town_id, town_action, CMD_DO_TOWN_ACTION); +} + +/* static */ AITown::TownRating AITown::GetRating(TownID town_id, AICompany::CompanyID company_id) +{ + if (!IsValidTown(town_id)) return INVALID_TOWN_RATING; + AICompany::CompanyID company = AICompany::ResolveCompanyID(company_id); + if (company == AICompany::INVALID_COMPANY) return INVALID_TOWN_RATING; + + const Town *t = ::GetTown(town_id); + if (!HasBit(t->have_ratings, company)) return TOWN_RATING_NONE; + return max(TOWN_RATING_APPALLING, (TownRating)((t->ratings[company] / 200) + 3)); +} + +/* static */ int AITown::GetAllowedNoise(TownID town_id) +{ + if (!IsValidTown(town_id)) return -1; + + const Town *t = ::GetTown(town_id); + if (_settings_game.economy.station_noise_level) { + return t->MaxTownNoise() - t->noise_reached; + } + + int num = 0; + const Station *st; + FOR_ALL_STATIONS(st) { + if (st->town == t && st->facilities & FACIL_AIRPORT && st->airport_type != AT_OILRIG) num++; + } + return max(0, 2 - num); +} diff --git a/src/ai/api/ai_town.hpp b/src/ai/api/ai_town.hpp new file mode 100644 index 000000000..94ba91e17 --- /dev/null +++ b/src/ai/api/ai_town.hpp @@ -0,0 +1,284 @@ +/* $Id$ */ + +/** @file ai_town.hpp Everything to query towns. */ + +#ifndef AI_TOWN_HPP +#define AI_TOWN_HPP + +#include "ai_object.hpp" +#include "ai_company.hpp" + +/** + * Class that handles all town related functions. + */ +class AITown : public AIObject { +public: + static const char *GetClassName() { return "AITown"; } + + /** + * Actions that one can perform on a town. + */ + enum TownAction { + /* Values are important, as they represent the internal state of the game. */ + + /** + * The cargo ratings temporary gains 25% of rating (in + * absolute percentage, so 10% becomes 35%, with a max of 99%) + * for all stations within 10 tiles. + */ + TOWN_ACTION_ADVERTISE_SMALL = 0, + + /** + * The cargo ratings temporary gains 44% of rating (in + * absolute percentage, so 10% becomes 54%, with a max of 99%) + * for all stations within 15 tiles. + */ + TOWN_ACTION_ADVERTISE_MEDIUM = 1, + + /** + * The cargo ratings temporary gains 63% of rating (in + * absolute percentage, so 10% becomes 73%, with a max of 99%) + * for all stations within 20 tiles. + */ + TOWN_ACTION_ADVERTISE_LARGE = 2, + + /** + * Rebuild the roads of this town for 6 months. + */ + TOWN_ACTION_ROAD_REBUILD = 3, + + /** + * Build a statue in this town. + */ + TOWN_ACTION_BUILD_STATUE = 4, + + /** + * Fund the creation of extra buildings for 3 months. + */ + TOWN_ACTION_FUND_BUILDINGS = 5, + + /** + * Buy exclusive rights for this town for 12 months. + */ + TOWN_ACTION_BUY_RIGHTS = 6, + + /** + * Bribe the town in order to get a higher rating. + */ + TOWN_ACTION_BRIBE = 7, + }; + + /** + * Different ratings one could have in a town. + */ + enum TownRating { + TOWN_RATING_NONE, ///< The company got no rating in the town. + TOWN_RATING_APPALLING, ///< The company got an appalling rating in the town . + TOWN_RATING_VERY_POOR, ///< The company got an very poor rating in the town. + TOWN_RATING_POOR, ///< The company got an poor rating in the town. + TOWN_RATING_MEDIOCRE, ///< The company got an mediocre rating in the town. + TOWN_RATING_GOOD, ///< The company got an good rating in the town. + TOWN_RATING_VERY_GOOD, ///< The company got an very good rating in the town. + TOWN_RATING_EXCELLENT, ///< The company got an excellent rating in the town. + TOWN_RATING_OUTSTANDING, ///< The company got an outstanding rating in the town. + INVALID_TOWN_RATING = -1, ///< The town rating for invalid towns/companies. + }; + + /** + * Gets the maximum town index; there are no valid towns with a higher index. + * @return The maximum town index. + * @post Return value is always non-negative. + */ + static TownID GetMaxTownID(); + + /** + * Gets the number of towns. This is different than GetMaxTownID() + * because of the way OpenTTD works internally. + * @return The number of towns. + * @post Return value is always non-negative. + */ + static int32 GetTownCount(); + + /** + * Checks whether the given town index is valid. + * @param town_id The index to check. + * @return True if and only if the town is valid. + */ + static bool IsValidTown(TownID town_id); + + /** + * Get the name of the town. + * @param town_id The town to get the name of. + * @pre IsValidTown(town_id). + * @return The name of the town. + */ + static const char *GetName(TownID town_id); + + /** + * Gets the number of inhabitants in the town. + * @param town_id The town to get the population of. + * @pre IsValidTown(town_id). + * @return The number of inhabitants. + * @post Return value is always non-negative. + */ + static int32 GetPopulation(TownID town_id); + + /** + * Gets the number of houses in the town. + * @param town_id The town to get the number of houses of. + * @pre IsValidTown(town_id). + * @return The number of houses. + * @post Return value is always non-negative. + */ + static int32 GetHouseCount(TownID town_id); + + /** + * Gets the location of the town. + * @param town_id The town to get the location of. + * @pre IsValidTown(town_id). + * @return The location of the town. + */ + static TileIndex GetLocation(TownID town_id); + + /** + * Get the total last month's production of the given cargo at a town. + * @param town_id The index of the town. + * @param cargo_id The index of the cargo. + * @pre IsValidTown(town_id). + * @pre AICargo::IsValidCargo(cargo_id). + * @pre AICargo::GetTownEffect(cargo_id) == TE_PASSENGERS || AICargo::GetTownEffect(cargo_id) == TE_MAIL. + * @return The last month's production of the given cargo for this town. + * @post Return value is always non-negative. + */ + static int32 GetLastMonthProduction(TownID town_id, CargoID cargo_id); + + /** + * Get the total amount of cargo transported from a town last month. + * @param town_id The index of the industry. + * @param cargo_id The index of the cargo. + * @pre IsValidTown(town_id). + * @pre AICargo::IsValidCargo(cargo_id). + * @pre AICargo::GetTownEffect(cargo_id) == TE_PASSENGERS || AICargo::GetTownEffect(cargo_id) == TE_MAIL. + * @return The amount of given cargo transported from this town last month. + * @post Return value is always non-negative. + */ + static int32 GetLastMonthTransported(TownID town_id, CargoID cargo_id); + + /** + * Get the maximum production of the given cargo at a town. + * @param town_id The index of the town. + * @param cargo_id The index of the cargo. + * @pre IsValidTown(town_id). + * @pre AICargo::IsValidCargo(cargo_id). + * @pre AICargo::GetTownEffect(cargo_id) == TE_PASSENGERS || AICargo::GetTownEffect(cargo_id) == TE_MAIL. + * @return The maximum production of the given cargo for this town. + * @post Return value is always non-negative. + */ + static int32 GetMaxProduction(TownID town_id, CargoID cargo_id); + + /** + * Get the manhattan distance from the tile to the AITown::GetLocation() + * of the town. + * @param town_id The town to get the distance to. + * @param tile The tile to get the distance to. + * @pre IsValidTown(town_id). + * @return The distance between town and tile. + */ + static int32 GetDistanceManhattanToTile(TownID town_id, TileIndex tile); + + /** + * Get the square distance from the tile to the AITown::GetLocation() + * of the town. + * @param town_id The town to get the distance to. + * @param tile The tile to get the distance to. + * @pre IsValidTown(town_id). + * @return The distance between town and tile. + */ + static int32 GetDistanceSquareToTile(TownID town_id, TileIndex tile); + + /** + * Find out if this tile is within the rating influence of a town. + * Stations on this tile influence the rating of the town. + * @param town_id The town to check. + * @param tile The tile to check. + * @pre IsValidTown(town_id). + * @return True if the tile is within the rating influence of the town. + */ + static bool IsWithinTownInfluence(TownID town_id, TileIndex tile); + + /** + * Find out if this town has a statue for the current company. + * @param town_id The town to check. + * @pre IsValidTown(town_id). + * @return True if the town has a statue. + */ + static bool HasStatue(TownID town_id); + + /** + * Find out how long the town is undergoing road reconstructions. + * @param town_id The town to check. + * @pre IsValidTown(town_id). + * @return The number of months the road reworks are still going to take. + * The value 0 means that there are currently no road reworks. + */ + static int GetRoadReworkDuration(TownID town_id); + + /** + * Find out which company currently has the exclusive rights of this town. + * @param town_id The town to check. + * @pre IsValidTown(town_id). + * @return The company that has the exclusive rights. The value + * AICompany::INVALID_COMPANY means that there are currently no + * exclusive rights given out to anyone. + */ + static AICompany::CompanyID GetExclusiveRightsCompany(TownID town_id); + + /** + * Find out how long the town is under influence of the exclusive rights. + * @param town_id The town to check. + * @pre IsValidTown(town_id). + * @return The number of months the exclusive rights hold. + * The value 0 means that there are currently no exclusive rights + * given out to anyone. + */ + static int32 GetExclusiveRightsDuration(TownID town_id); + + /** + * Find out if an action can currently be performed on the town. + * @param town_id The town to perform the action on. + * @param town_action The action to perform on the town. + * @pre IsValidTown(town_id). + * @return True if and only if the action can performed. + */ + static bool IsActionAvailable(TownID town_id, TownAction town_action); + + /** + * Perform a town action on this town. + * @param town_id The town to perform the action on. + * @param town_action The action to perform on the town. + * @pre IsValidTown(town_id). + * @pre IsActionAvailable(town_id, town_action). + * @return True if the action succeeded. + */ + static bool PerformTownAction(TownID town_id, TownAction town_action); + + /** + * Get the rating of a company within a town. + * @param town_id The town to get the rating for. + * @param company_id The company to get the rating for. + * @pre IsValidTown(town_id). + * @pre AICompany.ResolveCompanyID(company) != AICompany::INVALID_COMPANY. + * @return The rating as shown to humans. + */ + static TownRating GetRating(TownID town_id, AICompany::CompanyID company_id); + + /** + * Get the maximum level of noise that still can be added by airports + * before the town start to refuse building a new airport. + * @param town_id The town to get the allowed noise from. + * @return The noise that still can be added. + */ + static int GetAllowedNoise(TownID town_id); +}; + +#endif /* AI_TOWN_HPP */ diff --git a/src/ai/api/ai_town.hpp.sq b/src/ai/api/ai_town.hpp.sq new file mode 100644 index 000000000..664503923 --- /dev/null +++ b/src/ai/api/ai_town.hpp.sq @@ -0,0 +1,69 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_town.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AITown::TownAction GetParam(ForceType<AITown::TownAction>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AITown::TownAction)tmp; } + template <> int Return<AITown::TownAction>(HSQUIRRELVM vm, AITown::TownAction res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AITown::TownRating GetParam(ForceType<AITown::TownRating>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AITown::TownRating)tmp; } + template <> int Return<AITown::TownRating>(HSQUIRRELVM vm, AITown::TownRating res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AITown to be used as Squirrel parameter */ + template <> AITown *GetParam(ForceType<AITown *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITown *)instance; } + template <> AITown &GetParam(ForceType<AITown &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITown *)instance; } + template <> const AITown *GetParam(ForceType<const AITown *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITown *)instance; } + template <> const AITown &GetParam(ForceType<const AITown &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITown *)instance; } + template <> int Return<AITown *>(HSQUIRRELVM vm, AITown *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITown", res, NULL, DefSQDestructorCallback<AITown>); return 1; } +}; // namespace SQConvert + +void SQAITown_Register(Squirrel *engine) { + DefSQClass <AITown> SQAITown("AITown"); + SQAITown.PreRegister(engine); + SQAITown.AddConstructor<void (AITown::*)(), 1>(engine, "x"); + + SQAITown.DefSQConst(engine, AITown::TOWN_ACTION_ADVERTISE_SMALL, "TOWN_ACTION_ADVERTISE_SMALL"); + SQAITown.DefSQConst(engine, AITown::TOWN_ACTION_ADVERTISE_MEDIUM, "TOWN_ACTION_ADVERTISE_MEDIUM"); + SQAITown.DefSQConst(engine, AITown::TOWN_ACTION_ADVERTISE_LARGE, "TOWN_ACTION_ADVERTISE_LARGE"); + SQAITown.DefSQConst(engine, AITown::TOWN_ACTION_ROAD_REBUILD, "TOWN_ACTION_ROAD_REBUILD"); + SQAITown.DefSQConst(engine, AITown::TOWN_ACTION_BUILD_STATUE, "TOWN_ACTION_BUILD_STATUE"); + SQAITown.DefSQConst(engine, AITown::TOWN_ACTION_FUND_BUILDINGS, "TOWN_ACTION_FUND_BUILDINGS"); + SQAITown.DefSQConst(engine, AITown::TOWN_ACTION_BUY_RIGHTS, "TOWN_ACTION_BUY_RIGHTS"); + SQAITown.DefSQConst(engine, AITown::TOWN_ACTION_BRIBE, "TOWN_ACTION_BRIBE"); + SQAITown.DefSQConst(engine, AITown::TOWN_RATING_NONE, "TOWN_RATING_NONE"); + SQAITown.DefSQConst(engine, AITown::TOWN_RATING_APPALLING, "TOWN_RATING_APPALLING"); + SQAITown.DefSQConst(engine, AITown::TOWN_RATING_VERY_POOR, "TOWN_RATING_VERY_POOR"); + SQAITown.DefSQConst(engine, AITown::TOWN_RATING_POOR, "TOWN_RATING_POOR"); + SQAITown.DefSQConst(engine, AITown::TOWN_RATING_MEDIOCRE, "TOWN_RATING_MEDIOCRE"); + SQAITown.DefSQConst(engine, AITown::TOWN_RATING_GOOD, "TOWN_RATING_GOOD"); + SQAITown.DefSQConst(engine, AITown::TOWN_RATING_VERY_GOOD, "TOWN_RATING_VERY_GOOD"); + SQAITown.DefSQConst(engine, AITown::TOWN_RATING_EXCELLENT, "TOWN_RATING_EXCELLENT"); + SQAITown.DefSQConst(engine, AITown::TOWN_RATING_OUTSTANDING, "TOWN_RATING_OUTSTANDING"); + SQAITown.DefSQConst(engine, AITown::INVALID_TOWN_RATING, "INVALID_TOWN_RATING"); + + SQAITown.DefSQStaticMethod(engine, &AITown::GetClassName, "GetClassName", 1, "x"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetMaxTownID, "GetMaxTownID", 1, "x"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetTownCount, "GetTownCount", 1, "x"); + SQAITown.DefSQStaticMethod(engine, &AITown::IsValidTown, "IsValidTown", 2, "xi"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetName, "GetName", 2, "xi"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetPopulation, "GetPopulation", 2, "xi"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetHouseCount, "GetHouseCount", 2, "xi"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetLocation, "GetLocation", 2, "xi"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetLastMonthProduction, "GetLastMonthProduction", 3, "xii"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetLastMonthTransported, "GetLastMonthTransported", 3, "xii"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetMaxProduction, "GetMaxProduction", 3, "xii"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetDistanceManhattanToTile, "GetDistanceManhattanToTile", 3, "xii"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetDistanceSquareToTile, "GetDistanceSquareToTile", 3, "xii"); + SQAITown.DefSQStaticMethod(engine, &AITown::IsWithinTownInfluence, "IsWithinTownInfluence", 3, "xii"); + SQAITown.DefSQStaticMethod(engine, &AITown::HasStatue, "HasStatue", 2, "xi"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetRoadReworkDuration, "GetRoadReworkDuration", 2, "xi"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetExclusiveRightsCompany, "GetExclusiveRightsCompany", 2, "xi"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetExclusiveRightsDuration, "GetExclusiveRightsDuration", 2, "xi"); + SQAITown.DefSQStaticMethod(engine, &AITown::IsActionAvailable, "IsActionAvailable", 3, "xii"); + SQAITown.DefSQStaticMethod(engine, &AITown::PerformTownAction, "PerformTownAction", 3, "xii"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetRating, "GetRating", 3, "xii"); + SQAITown.DefSQStaticMethod(engine, &AITown::GetAllowedNoise, "GetAllowedNoise", 2, "xi"); + + SQAITown.PostRegister(engine); +} diff --git a/src/ai/api/ai_townlist.cpp b/src/ai/api/ai_townlist.cpp new file mode 100644 index 000000000..34612d857 --- /dev/null +++ b/src/ai/api/ai_townlist.cpp @@ -0,0 +1,15 @@ +/* $Id$ */ + +/** @file ai_townlist.cpp Implementation of AITownList and friends. */ + +#include "ai_townlist.hpp" +#include "../../openttd.h" +#include "../../town.h" + +AITownList::AITownList() +{ + Town *t; + FOR_ALL_TOWNS(t) { + this->AddItem(t->index); + } +} diff --git a/src/ai/api/ai_townlist.hpp b/src/ai/api/ai_townlist.hpp new file mode 100644 index 000000000..0e2eb1530 --- /dev/null +++ b/src/ai/api/ai_townlist.hpp @@ -0,0 +1,20 @@ +/* $Id$ */ + +/** @file ai_townlist.hpp List all the towns. */ + +#ifndef AI_TOWNLIST_HPP +#define AI_TOWNLIST_HPP + +#include "ai_abstractlist.hpp" + +/** + * Creates a list of towns that are currently on the map. + * @ingroup AIList + */ +class AITownList : public AIAbstractList { +public: + static const char *GetClassName() { return "AITownList"; } + AITownList(); +}; + +#endif /* AI_TOWNLIST_HPP */ diff --git a/src/ai/api/ai_townlist.hpp.sq b/src/ai/api/ai_townlist.hpp.sq new file mode 100644 index 000000000..31be65144 --- /dev/null +++ b/src/ai/api/ai_townlist.hpp.sq @@ -0,0 +1,23 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_townlist.hpp" + +namespace SQConvert { + /* Allow AITownList to be used as Squirrel parameter */ + template <> AITownList *GetParam(ForceType<AITownList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITownList *)instance; } + template <> AITownList &GetParam(ForceType<AITownList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownList *)instance; } + template <> const AITownList *GetParam(ForceType<const AITownList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITownList *)instance; } + template <> const AITownList &GetParam(ForceType<const AITownList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownList *)instance; } + template <> int Return<AITownList *>(HSQUIRRELVM vm, AITownList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownList", res, NULL, DefSQDestructorCallback<AITownList>); return 1; } +}; // namespace SQConvert + +void SQAITownList_Register(Squirrel *engine) { + DefSQClass <AITownList> SQAITownList("AITownList"); + SQAITownList.PreRegister(engine, "AIAbstractList"); + SQAITownList.AddConstructor<void (AITownList::*)(), 1>(engine, "x"); + + SQAITownList.DefSQStaticMethod(engine, &AITownList::GetClassName, "GetClassName", 1, "x"); + + SQAITownList.PostRegister(engine); +} diff --git a/src/ai/api/ai_tunnel.cpp b/src/ai/api/ai_tunnel.cpp new file mode 100644 index 000000000..1991ef89b --- /dev/null +++ b/src/ai/api/ai_tunnel.cpp @@ -0,0 +1,119 @@ +/* $Id$ */ + +/** @file ai_tunnel.cpp Implementation of AITunnel. */ + +#include "ai_tunnel.hpp" +#include "ai_map.hpp" +#include "ai_rail.hpp" +#include "../ai_instance.hpp" +#include "../../openttd.h" +#include "../../landscape.h" +#include "../../tunnel_map.h" +#include "../../road_type.h" +#include "../../command_func.h" +#include "../../tunnelbridge.h" +#include "../../road_func.h" + +/* static */ bool AITunnel::IsTunnelTile(TileIndex tile) +{ + if (!::IsValidTile(tile)) return false; + return ::IsTunnelTile(tile); +} + +/* static */ TileIndex AITunnel::GetOtherTunnelEnd(TileIndex tile) +{ + if (!::IsValidTile(tile)) return INVALID_TILE; + + /* If it's a tunnel alread, take the easy way out! */ + if (IsTunnelTile(tile)) return ::GetOtherTunnelEnd(tile); + + ::DoCommand(tile, 0, 0, DC_AUTO, CMD_BUILD_TUNNEL); + return _build_tunnel_endtile == 0 ? INVALID_TILE : _build_tunnel_endtile; +} + +static void _DoCommandReturnBuildTunnel2(class AIInstance *instance) +{ + if (!AITunnel::_BuildTunnelRoad2()) { + AIObject::SetLastCommandRes(false); + AIInstance::DoCommandReturn(instance); + return; + } + + /* This can never happen, as in test-mode this callback is never executed, + * and in execute-mode, the other callback is called. */ + NOT_REACHED(); +} + +static void _DoCommandReturnBuildTunnel1(class AIInstance *instance) +{ + if (!AITunnel::_BuildTunnelRoad1()) { + AIObject::SetLastCommandRes(false); + AIInstance::DoCommandReturn(instance); + return; + } + + /* This can never happen, as in test-mode this callback is never executed, + * and in execute-mode, the other callback is called. */ + NOT_REACHED(); +} + +/* static */ bool AITunnel::BuildTunnel(AIVehicle::VehicleType vehicle_type, TileIndex start) +{ + EnforcePrecondition(false, ::IsValidTile(start)); + EnforcePrecondition(false, vehicle_type == AIVehicle::VEHICLE_RAIL || vehicle_type == AIVehicle::VEHICLE_ROAD); + EnforcePrecondition(false, vehicle_type != AIVehicle::VEHICLE_RAIL || AIRail::IsRailTypeAvailable(AIRail::GetCurrentRailType())); + + uint type = 0; + if (vehicle_type == AIVehicle::VEHICLE_ROAD) { + type |= (TRANSPORT_ROAD << 9); + type |= RoadTypeToRoadTypes((::RoadType)AIObject::GetRoadType()); + } else { + type |= (TRANSPORT_RAIL << 9); + type |= AIRail::GetCurrentRailType(); + } + + /* For rail we do nothing special */ + if (vehicle_type == AIVehicle::VEHICLE_RAIL) { + return AIObject::DoCommand(start, type, 0, CMD_BUILD_TUNNEL); + } + + AIObject::SetCallbackVariable(0, start); + if (!AIObject::DoCommand(start, type, 0, CMD_BUILD_TUNNEL, NULL, &_DoCommandReturnBuildTunnel1)) return false; + + /* In case of test-mode, test if we can build both road pieces */ + return _BuildTunnelRoad1(); +} + +/* static */ bool AITunnel::_BuildTunnelRoad1() +{ + /* Build the piece of road on the 'start' side of the tunnel */ + TileIndex end = AIObject::GetCallbackVariable(0); + TileIndex start = AITunnel::GetOtherTunnelEnd(end); + + DiagDirection dir_1 = (DiagDirection)((::TileX(start) == ::TileX(end)) ? (::TileY(start) < ::TileY(end) ? DIAGDIR_NW : DIAGDIR_SE) : (::TileX(start) < ::TileX(end) ? DIAGDIR_NE : DIAGDIR_SW)); + DiagDirection dir_2 = ::ReverseDiagDir(dir_1); + + if (!AIObject::DoCommand(start + ::TileOffsByDiagDir(dir_1), ::DiagDirToRoadBits(dir_2) | (AIObject::GetRoadType() << 4), 0, CMD_BUILD_ROAD, NULL, &_DoCommandReturnBuildTunnel2)) return false; + + /* In case of test-mode, test the other road piece too */ + return _BuildTunnelRoad2(); +} + +/* static */ bool AITunnel::_BuildTunnelRoad2() +{ + /* Build the piece of road on the 'end' side of the tunnel */ + TileIndex end = AIObject::GetCallbackVariable(0); + TileIndex start = AITunnel::GetOtherTunnelEnd(end); + + DiagDirection dir_1 = (DiagDirection)((::TileX(start) == ::TileX(end)) ? (::TileY(start) < ::TileY(end) ? DIAGDIR_NW : DIAGDIR_SE) : (::TileX(start) < ::TileX(end) ? DIAGDIR_NE : DIAGDIR_SW)); + DiagDirection dir_2 = ::ReverseDiagDir(dir_1); + + return AIObject::DoCommand(end + ::TileOffsByDiagDir(dir_2), ::DiagDirToRoadBits(dir_1) | (AIObject::GetRoadType() << 4), 0, CMD_BUILD_ROAD); +} + +/* static */ bool AITunnel::RemoveTunnel(TileIndex tile) +{ + EnforcePrecondition(false, IsTunnelTile(tile)); + + return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR); +} diff --git a/src/ai/api/ai_tunnel.hpp b/src/ai/api/ai_tunnel.hpp new file mode 100644 index 000000000..625237905 --- /dev/null +++ b/src/ai/api/ai_tunnel.hpp @@ -0,0 +1,103 @@ +/* $Id$ */ + +/** @file ai_tunnel.hpp Everything to query and build tunnels. */ + +#ifndef AI_TUNNEL_HPP +#define AI_TUNNEL_HPP + +#include "ai_object.hpp" +#include "ai_vehicle.hpp" + +/** + * Class that handles all tunnel related functions. + */ +class AITunnel : public AIObject { +public: + static const char *GetClassName() { return "AITunnel"; } + + /** + * All tunnel related errors. + */ + enum ErrorMessages { + + /** Base for bridge related errors */ + ERR_TUNNEL_BASE = AIError::ERR_CAT_TUNNEL << AIError::ERR_CAT_BIT_SIZE, + + /** Can't build tunnels on water */ + ERR_TUNNEL_CANNOT_BUILD_ON_WATER, // [STR_3807_CAN_T_BUILD_ON_WATER] + + /** The start tile must slope either North, South, West or East */ + ERR_TUNNEL_START_SITE_UNSUITABLE, // [STR_500B_SITE_UNSUITABLE_FOR_TUNNEL] + + /** An other tunnel is in the way */ + ERR_TUNNEL_ANOTHER_TUNNEL_IN_THE_WAY, // [STR_5003_ANOTHER_TUNNEL_IN_THE_WAY] + + /** Unable to excavate land at the end to create the tunnel's exit */ + ERR_TUNNEL_END_SITE_UNSUITABLE, // [STR_5005_UNABLE_TO_EXCAVATE_LAND] + }; + + /** + * Check whether the tile is an entrance to a tunnel. + * @param tile The tile to check. + * @pre AIMap::IsValidTile(tile). + * @return True if and only if the tile is the beginning or end of a tunnel. + */ + static bool IsTunnelTile(TileIndex tile); + + /** + * Get the tile that exits on the other end of a (would be) tunnel starting + * at tile. + * @param tile The tile that is an entrance to a tunnel or the tile where you may want to build a tunnel. + * @pre AIMap::IsValidTile(tile). + * @return The TileIndex that is the other end of the (would be) tunnel, or + * INVALID_TILE if no other end was found (can't build tunnel). + */ + static TileIndex GetOtherTunnelEnd(TileIndex tile); + +#ifndef DOXYGEN_SKIP + /** + * Internal function to help BuildTunnel in case of road. + */ + static bool _BuildTunnelRoad1(); + + /** + * Internal function to help BuildTunnel in case of road. + */ + static bool _BuildTunnelRoad2(); +#endif + + /** + * Builds a tunnel starting at start. The direction of the tunnel depends + * on the slope of the start tile. Tunnels can be created for either + * rails or roads; use the appropriate AIVehicle::VehicleType. + * As an extra for road, this functions builds two half-pieces of road on + * each end of the tunnel, making it easier for you to connect it to your + * network. + * @param start Where to start the tunnel. + * @param vehicle_type The vehicle-type of tunnel to build. + * @pre AIMap::IsValidTile(start). + * @pre vehicle_type == AIVehicle::VEHICLE_ROAD || (vehicle_type == AIVehicle::VEHICLE_RAIL && + * AIRail::IsRailTypeAvailable(AIRail::GetCurrentRailType())). + * @exception AIError::ERR_AREA_NOT_CLEAR + * @exception AITunnel::ERR_TUNNEL_CANNOT_BUILD_ON_WATER + * @exception AITunnel::ERR_TUNNEL_START_SITE_UNSUITABLE + * @exception AITunnel::ERR_TUNNEL_ANOTHER_TUNNEL_IN_THE_WAY + * @exception AITunnel::ERR_TUNNEL_END_SITE_UNSUITABLE + * @return Whether the tunnel has been/can be build or not. + * @note The slope of a tile can be determined by AITile::GetSlope(TileIndex). + * @note No matter if the road pieces were build or not, if building the + * tunnel succeeded, this function returns true. + */ + static bool BuildTunnel(AIVehicle::VehicleType vehicle_type, TileIndex start); + + /** + * Remove the tunnel whose entrance is located at tile. + * @param tile The tile that is an entrance to a tunnel. + * @pre AIMap::IsValidTile(tile) && IsTunnelTile(tile). + * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY + * @return Whether the tunnel has been/can be removed or not. + */ + static bool RemoveTunnel(TileIndex tile); +}; + +#endif /* AI_TUNNEL_HPP */ diff --git a/src/ai/api/ai_tunnel.hpp.sq b/src/ai/api/ai_tunnel.hpp.sq new file mode 100644 index 000000000..fd2f6959c --- /dev/null +++ b/src/ai/api/ai_tunnel.hpp.sq @@ -0,0 +1,47 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_tunnel.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AITunnel::ErrorMessages GetParam(ForceType<AITunnel::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AITunnel::ErrorMessages)tmp; } + template <> int Return<AITunnel::ErrorMessages>(HSQUIRRELVM vm, AITunnel::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AITunnel to be used as Squirrel parameter */ + template <> AITunnel *GetParam(ForceType<AITunnel *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITunnel *)instance; } + template <> AITunnel &GetParam(ForceType<AITunnel &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITunnel *)instance; } + template <> const AITunnel *GetParam(ForceType<const AITunnel *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITunnel *)instance; } + template <> const AITunnel &GetParam(ForceType<const AITunnel &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITunnel *)instance; } + template <> int Return<AITunnel *>(HSQUIRRELVM vm, AITunnel *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITunnel", res, NULL, DefSQDestructorCallback<AITunnel>); return 1; } +}; // namespace SQConvert + +void SQAITunnel_Register(Squirrel *engine) { + DefSQClass <AITunnel> SQAITunnel("AITunnel"); + SQAITunnel.PreRegister(engine); + SQAITunnel.AddConstructor<void (AITunnel::*)(), 1>(engine, "x"); + + SQAITunnel.DefSQConst(engine, AITunnel::ERR_TUNNEL_BASE, "ERR_TUNNEL_BASE"); + SQAITunnel.DefSQConst(engine, AITunnel::ERR_TUNNEL_CANNOT_BUILD_ON_WATER, "ERR_TUNNEL_CANNOT_BUILD_ON_WATER"); + SQAITunnel.DefSQConst(engine, AITunnel::ERR_TUNNEL_START_SITE_UNSUITABLE, "ERR_TUNNEL_START_SITE_UNSUITABLE"); + SQAITunnel.DefSQConst(engine, AITunnel::ERR_TUNNEL_ANOTHER_TUNNEL_IN_THE_WAY, "ERR_TUNNEL_ANOTHER_TUNNEL_IN_THE_WAY"); + SQAITunnel.DefSQConst(engine, AITunnel::ERR_TUNNEL_END_SITE_UNSUITABLE, "ERR_TUNNEL_END_SITE_UNSUITABLE"); + + AIError::RegisterErrorMap(STR_3807_CAN_T_BUILD_ON_WATER, AITunnel::ERR_TUNNEL_CANNOT_BUILD_ON_WATER); + AIError::RegisterErrorMap(STR_500B_SITE_UNSUITABLE_FOR_TUNNEL, AITunnel::ERR_TUNNEL_START_SITE_UNSUITABLE); + AIError::RegisterErrorMap(STR_5003_ANOTHER_TUNNEL_IN_THE_WAY, AITunnel::ERR_TUNNEL_ANOTHER_TUNNEL_IN_THE_WAY); + AIError::RegisterErrorMap(STR_5005_UNABLE_TO_EXCAVATE_LAND, AITunnel::ERR_TUNNEL_END_SITE_UNSUITABLE); + + AIError::RegisterErrorMapString(AITunnel::ERR_TUNNEL_CANNOT_BUILD_ON_WATER, "ERR_TUNNEL_CANNOT_BUILD_ON_WATER"); + AIError::RegisterErrorMapString(AITunnel::ERR_TUNNEL_START_SITE_UNSUITABLE, "ERR_TUNNEL_START_SITE_UNSUITABLE"); + AIError::RegisterErrorMapString(AITunnel::ERR_TUNNEL_ANOTHER_TUNNEL_IN_THE_WAY, "ERR_TUNNEL_ANOTHER_TUNNEL_IN_THE_WAY"); + AIError::RegisterErrorMapString(AITunnel::ERR_TUNNEL_END_SITE_UNSUITABLE, "ERR_TUNNEL_END_SITE_UNSUITABLE"); + + SQAITunnel.DefSQStaticMethod(engine, &AITunnel::GetClassName, "GetClassName", 1, "x"); + SQAITunnel.DefSQStaticMethod(engine, &AITunnel::IsTunnelTile, "IsTunnelTile", 2, "xi"); + SQAITunnel.DefSQStaticMethod(engine, &AITunnel::GetOtherTunnelEnd, "GetOtherTunnelEnd", 2, "xi"); + SQAITunnel.DefSQStaticMethod(engine, &AITunnel::BuildTunnel, "BuildTunnel", 3, "xii"); + SQAITunnel.DefSQStaticMethod(engine, &AITunnel::RemoveTunnel, "RemoveTunnel", 2, "xi"); + + SQAITunnel.PostRegister(engine); +} diff --git a/src/ai/api/ai_types.hpp b/src/ai/api/ai_types.hpp new file mode 100644 index 000000000..086cf75e0 --- /dev/null +++ b/src/ai/api/ai_types.hpp @@ -0,0 +1,40 @@ +/* $Id$ */ + +/** @file ai_types.hpp Defines all the types of the game, like VehicleID, .... */ + +#ifndef AI_TYPES_HPP +#define AI_TYPES_HPP + +#include "../../core/overflowsafe_type.hpp" +#include "../../company_type.h" + +/* Define all types here, so we don't have to include the whole _type.h maze */ +typedef uint BridgeType; //!< Internal name, not of any use for you. +typedef byte CargoID; //!< The ID of a cargo. +class CommandCost; //!< The cost of a command. +typedef uint16 EngineID; //!< The ID of an engine. +typedef uint16 GroupID; //!< The ID of a group. +typedef uint16 IndustryID; //!< The ID of an industry. +typedef uint8 IndustryType; //!< The ID of an industry-type. +typedef OverflowSafeInt64 Money; //!< Money, stored in a 32bit/64bit safe way. For AIs money is always in pounds. +typedef uint16 SignID; //!< The ID of a sign. +typedef uint16 StationID; //!< The ID of a station. +typedef uint16 StringID; //!< The ID of a string. +typedef uint32 TileIndex; //!< The ID of a tile (just named differently). +typedef uint16 TownID; //!< The ID of a town. +typedef uint16 VehicleID; //!< The ID of a vehicle. + +/* Types we defined ourself, as the OpenTTD core doesn't have them (yet) */ +typedef uint AIErrorType; //!< The types of errors inside the NoAI framework. +typedef BridgeType BridgeID; //!< The ID of a bridge. +typedef uint16 SubsidyID; //!< The ID of a subsidy. + +#ifndef _SQUIRREL_H_ +/* Life becomes easier when we can tell about a function it needs the VM, but + * without really including 'squirrel.h'. */ +typedef struct SQVM *HSQUIRRELVM; //!< Pointer to Squirrel Virtual Machine. +typedef int SQInteger; //!< Squirrel Integer. +typedef struct SQObject HSQOBJECT; //!< Squirrel Object (fake declare) +#endif + +#endif /* AI_TYPES_HPP */ diff --git a/src/ai/api/ai_vehicle.cpp b/src/ai/api/ai_vehicle.cpp new file mode 100644 index 000000000..9532e3caf --- /dev/null +++ b/src/ai/api/ai_vehicle.cpp @@ -0,0 +1,389 @@ +/* $Id$ */ + +/** @file ai_vehicle.cpp Implementation of AIVehicle. */ + +#include "ai_vehicle.hpp" +#include "ai_engine.hpp" +#include "ai_cargo.hpp" +#include "ai_order.hpp" +#include "ai_gamesettings.hpp" +#include "../ai_instance.hpp" +#include "../../openttd.h" +#include "../../company_func.h" +#include "../../aircraft.h" +#include "../../string_func.h" +#include "../../strings_func.h" +#include "../../core/alloc_func.hpp" +#include "../../command_func.h" +#include "../../roadveh.h" +#include "../../train.h" +#include "../../vehicle_func.h" +#include "table/strings.h" + +/* static */ bool AIVehicle::IsValidVehicle(VehicleID vehicle_id) +{ + if (!::IsValidVehicleID(vehicle_id)) return false; + const Vehicle *v = ::GetVehicle(vehicle_id); + return v->owner == _current_company && (v->IsPrimaryVehicle() || (v->type == VEH_TRAIN && ::IsFreeWagon(v))); +} + +/* static */ int32 AIVehicle::GetNumWagons(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + int num = 1; + if (::GetVehicle(vehicle_id)->type == VEH_TRAIN) { + const Vehicle *v = ::GetVehicle(vehicle_id); + while ((v = GetNextUnit(v)) != NULL) num++; + } + + return num; +} + +/* static */ int AIVehicle::GetLength(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + const Vehicle *v = ::GetVehicle(vehicle_id); + switch (v->type) { + case VEH_ROAD: return v->u.road.cached_veh_length; + case VEH_TRAIN: return v->u.rail.cached_total_length; + default: return -1; + } +} + +/* static */ VehicleID AIVehicle::BuildVehicle(TileIndex depot, EngineID engine_id) +{ + EnforcePrecondition(INVALID_VEHICLE, AIEngine::IsValidEngine(engine_id)); + + ::VehicleType type = ::GetEngine(engine_id)->type; + + EnforcePreconditionCustomError(INVALID_VEHICLE, !AIGameSettings::IsDisabledVehicleType((AIVehicle::VehicleType)type), AIVehicle::ERR_VEHICLE_BUILD_DISABLED); + + if (!AIObject::DoCommand(depot, engine_id, 0, ::GetCmdBuildVeh(type), NULL, &AIInstance::DoCommandReturnVehicleID)) return INVALID_VEHICLE; + + /* In case of test-mode, we return VehicleID 0 */ + return 0; +} + +/* static */ VehicleID AIVehicle::CloneVehicle(TileIndex depot, VehicleID vehicle_id, bool share_orders) +{ + EnforcePrecondition(false, IsValidVehicle(vehicle_id)); + + if (!AIObject::DoCommand(depot, vehicle_id, share_orders, CMD_CLONE_VEHICLE, NULL, &AIInstance::DoCommandReturnVehicleID)) return INVALID_VEHICLE; + + /* In case of test-mode, we return VehicleID 0 */ + return 0; +} + +/* static */ bool AIVehicle::MoveWagon(VehicleID source_vehicle_id, int source_wagon, bool move_attached_wagons, int dest_vehicle_id, int dest_wagon) +{ + EnforcePrecondition(false, IsValidVehicle(source_vehicle_id) && source_wagon < GetNumWagons(source_vehicle_id)); + EnforcePrecondition(false, dest_vehicle_id == -1 || (IsValidVehicle(dest_vehicle_id) && dest_wagon < GetNumWagons(dest_vehicle_id))); + EnforcePrecondition(false, ::GetVehicle(source_vehicle_id)->type == VEH_TRAIN); + EnforcePrecondition(false, dest_vehicle_id == -1 || ::GetVehicle(dest_vehicle_id)->type == VEH_TRAIN); + + const Vehicle *v = ::GetVehicle(source_vehicle_id); + while (source_wagon-- > 0) v = GetNextUnit(v); + const Vehicle *w = NULL; + if (dest_vehicle_id != -1) { + w = ::GetVehicle(dest_vehicle_id); + while (dest_wagon-- > 0) w = GetNextUnit(w); + } + + return AIObject::DoCommand(0, v->index | ((w == NULL ? INVALID_VEHICLE : w->index) << 16), move_attached_wagons ? 1 : 0, CMD_MOVE_RAIL_VEHICLE); +} + +/* static */ int AIVehicle::GetRefitCapacity(VehicleID vehicle_id, CargoID cargo) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + if (!AICargo::IsValidCargo(cargo)) return -1; + + CommandCost res = ::DoCommand(0, vehicle_id, cargo, DC_QUERY_COST, GetCmdRefitVeh(::GetVehicle(vehicle_id))); + return CmdSucceeded(res) ? _returned_refit_capacity : -1; +} + +/* static */ bool AIVehicle::RefitVehicle(VehicleID vehicle_id, CargoID cargo) +{ + EnforcePrecondition(false, IsValidVehicle(vehicle_id) && AICargo::IsValidCargo(cargo)); + + return AIObject::DoCommand(0, vehicle_id, cargo, GetCmdRefitVeh(::GetVehicle(vehicle_id))); +} + + +/* static */ bool AIVehicle::SellVehicle(VehicleID vehicle_id) +{ + EnforcePrecondition(false, IsValidVehicle(vehicle_id)); + + const Vehicle *v = ::GetVehicle(vehicle_id); + return AIObject::DoCommand(0, vehicle_id, v->type == VEH_TRAIN ? 1 : 0, GetCmdSellVeh(v)); +} + +/* static */ bool AIVehicle::SellWagon(VehicleID vehicle_id, int wagon, bool sell_attached_wagons) +{ + EnforcePrecondition(false, IsValidVehicle(vehicle_id) && wagon < GetNumWagons(vehicle_id)); + EnforcePrecondition(false, ::GetVehicle(vehicle_id)->type == VEH_TRAIN); + + const Vehicle *v = ::GetVehicle(vehicle_id); + while (wagon-- > 0) v = GetNextUnit(v); + + return AIObject::DoCommand(0, v->index, sell_attached_wagons ? 1 : 0, CMD_SELL_RAIL_WAGON); +} + +/* static */ bool AIVehicle::SendVehicleToDepot(VehicleID vehicle_id) +{ + EnforcePrecondition(false, IsValidVehicle(vehicle_id)); + + return AIObject::DoCommand(0, vehicle_id, 0, GetCmdSendToDepot(::GetVehicle(vehicle_id))); +} + +/* static */ bool AIVehicle::IsInDepot(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return false; + return ::GetVehicle(vehicle_id)->IsInDepot(); +} + +/* static */ bool AIVehicle::IsStoppedInDepot(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return false; + return ::GetVehicle(vehicle_id)->IsStoppedInDepot(); +} + +/* static */ bool AIVehicle::StartStopVehicle(VehicleID vehicle_id) +{ + EnforcePrecondition(false, IsValidVehicle(vehicle_id)); + + return AIObject::DoCommand(0, vehicle_id, 0, CMD_START_STOP_VEHICLE); +} + +/* static */ bool AIVehicle::SkipToVehicleOrder(VehicleID vehicle_id, AIOrder::OrderPosition order_position) +{ + order_position = AIOrder::ResolveOrderPosition(vehicle_id, order_position); + + EnforcePrecondition(false, AIOrder::IsValidVehicleOrder(vehicle_id, order_position)); + + return AIObject::DoCommand(0, vehicle_id, order_position, CMD_SKIP_TO_ORDER); +} + +/* static */ bool AIVehicle::ReverseVehicle(VehicleID vehicle_id) +{ + EnforcePrecondition(false, IsValidVehicle(vehicle_id)); + EnforcePrecondition(false, ::GetVehicle(vehicle_id)->type == VEH_ROAD || ::GetVehicle(vehicle_id)->type == VEH_TRAIN); + + switch (::GetVehicle(vehicle_id)->type) { + case VEH_ROAD: return AIObject::DoCommand(0, vehicle_id, 0, CMD_TURN_ROADVEH); + case VEH_TRAIN: return AIObject::DoCommand(0, vehicle_id, 0, CMD_REVERSE_TRAIN_DIRECTION); + default: NOT_REACHED(); + } +} + +/* static */ bool AIVehicle::SetName(VehicleID vehicle_id, const char *name) +{ + EnforcePrecondition(false, IsValidVehicle(vehicle_id)); + EnforcePrecondition(false, !::StrEmpty(name)); + EnforcePreconditionCustomError(false, ::strlen(name) < MAX_LENGTH_VEHICLE_NAME_BYTES, AIError::ERR_PRECONDITION_STRING_TOO_LONG); + + return AIObject::DoCommand(0, vehicle_id, 0, CMD_RENAME_VEHICLE, name); +} + +/* static */ TileIndex AIVehicle::GetLocation(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return INVALID_TILE; + + const Vehicle *v = ::GetVehicle(vehicle_id); + if (v->type == VEH_AIRCRAFT) { + uint x = Clamp(v->x_pos / TILE_SIZE, 0, ::MapSizeX() - 2); + uint y = Clamp(v->y_pos / TILE_SIZE, 0, ::MapSizeY() - 2); + return ::TileXY(x, y); + } + + return v->tile; +} + +/* static */ EngineID AIVehicle::GetEngineType(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return INVALID_ENGINE; + + return ::GetVehicle(vehicle_id)->engine_type; +} + +/* static */ EngineID AIVehicle::GetWagonEngineType(VehicleID vehicle_id, int wagon) +{ + if (!IsValidVehicle(vehicle_id)) return INVALID_ENGINE; + if (wagon >= GetNumWagons(vehicle_id)) return INVALID_ENGINE; + + const Vehicle *v = ::GetVehicle(vehicle_id); + if (v->type == VEH_TRAIN) { + while (wagon-- > 0) v = GetNextUnit(v); + } + return v->engine_type; +} + +/* static */ int32 AIVehicle::GetUnitNumber(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + return ::GetVehicle(vehicle_id)->unitnumber; +} + +/* static */ const char *AIVehicle::GetName(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return NULL; + + static const int len = 64; + char *vehicle_name = MallocT<char>(len); + + ::SetDParam(0, vehicle_id); + ::GetString(vehicle_name, STR_VEHICLE_NAME, &vehicle_name[len - 1]); + return vehicle_name; +} + +/* static */ int32 AIVehicle::GetAge(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + return ::GetVehicle(vehicle_id)->age; +} + +/* static */ int32 AIVehicle::GetWagonAge(VehicleID vehicle_id, int wagon) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + if (wagon >= GetNumWagons(vehicle_id)) return -1; + + const Vehicle *v = ::GetVehicle(vehicle_id); + if (v->type == VEH_TRAIN) { + while (wagon-- > 0) v = GetNextUnit(v); + } + return v->age; +} + +/* static */ int32 AIVehicle::GetMaxAge(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + return ::GetVehicle(vehicle_id)->max_age; +} + +/* static */ int32 AIVehicle::GetAgeLeft(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + return ::GetVehicle(vehicle_id)->max_age - ::GetVehicle(vehicle_id)->age; +} + +/* static */ int32 AIVehicle::GetCurrentSpeed(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + return ::GetVehicle(vehicle_id)->GetDisplaySpeed(); +} + +/* static */ AIVehicle::VehicleState AIVehicle::GetState(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return AIVehicle::VS_INVALID; + + const Vehicle *v = ::GetVehicle(vehicle_id); + byte vehstatus = v->vehstatus; + + if (vehstatus & ::VS_CRASHED) return AIVehicle::VS_CRASHED; + if (v->breakdown_ctr != 0) return AIVehicle::VS_BROKEN; + if (v->IsStoppedInDepot()) return AIVehicle::VS_IN_DEPOT; + if (vehstatus & ::VS_STOPPED) return AIVehicle::VS_STOPPED; + if (v->current_order.IsType(OT_LOADING)) return AIVehicle::VS_AT_STATION; + return AIVehicle::VS_RUNNING; +} + +/* static */ Money AIVehicle::GetRunningCost(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + return ::GetVehicle(vehicle_id)->GetRunningCost() >> 8; +} + +/* static */ Money AIVehicle::GetProfitThisYear(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + return ::GetVehicle(vehicle_id)->GetDisplayProfitThisYear(); +} + +/* static */ Money AIVehicle::GetProfitLastYear(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + return ::GetVehicle(vehicle_id)->GetDisplayProfitLastYear(); +} + +/* static */ Money AIVehicle::GetCurrentValue(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + + return ::GetVehicle(vehicle_id)->value; +} + +/* static */ AIVehicle::VehicleType AIVehicle::GetVehicleType(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return VEHICLE_INVALID; + + switch (::GetVehicle(vehicle_id)->type) { + case VEH_ROAD: return VEHICLE_ROAD; + case VEH_TRAIN: return VEHICLE_RAIL; + case VEH_SHIP: return VEHICLE_WATER; + case VEH_AIRCRAFT: return VEHICLE_AIR; + default: return VEHICLE_INVALID; + } +} + +/* static */ AIRoad::RoadType AIVehicle::GetRoadType(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return AIRoad::ROADTYPE_INVALID; + if (GetVehicleType(vehicle_id) != VEHICLE_ROAD) return AIRoad::ROADTYPE_INVALID; + + return (AIRoad::RoadType)::GetVehicle(vehicle_id)->u.road.roadtype; +} + +/* static */ int32 AIVehicle::GetCapacity(VehicleID vehicle_id, CargoID cargo) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + if (!AICargo::IsValidCargo(cargo)) return -1; + + uint32 amount = 0; + for (const Vehicle *v = ::GetVehicle(vehicle_id); v != NULL; v = v->Next()) { + if (v->cargo_type == cargo) amount += v->cargo_cap; + } + + return amount; +} + +/* static */ int32 AIVehicle::GetCargoLoad(VehicleID vehicle_id, CargoID cargo) +{ + if (!IsValidVehicle(vehicle_id)) return -1; + if (!AICargo::IsValidCargo(cargo)) return -1; + + uint32 amount = 0; + for (const Vehicle *v = ::GetVehicle(vehicle_id); v != NULL; v = v->Next()) { + if (v->cargo_type == cargo) amount += v->cargo.Count(); + } + + return amount; +} + +/* static */ GroupID AIVehicle::GetGroupID(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return ::INVALID_GROUP; + + return ::GetVehicle(vehicle_id)->group_id; +} + +/* static */ bool AIVehicle::IsArticulated(VehicleID vehicle_id) +{ + if (!IsValidVehicle(vehicle_id)) return false; + if (GetVehicleType(vehicle_id) != VEHICLE_ROAD && GetVehicleType(vehicle_id) != VEHICLE_RAIL) return false; + + const Vehicle *v = ::GetVehicle(vehicle_id); + switch (v->type) { + case VEH_ROAD: return RoadVehHasArticPart(v); + case VEH_TRAIN: return EngineHasArticPart(v); + default: NOT_REACHED(); + } +} diff --git a/src/ai/api/ai_vehicle.hpp b/src/ai/api/ai_vehicle.hpp new file mode 100644 index 000000000..8120fe947 --- /dev/null +++ b/src/ai/api/ai_vehicle.hpp @@ -0,0 +1,477 @@ +/* $Id$ */ + +/** @file ai_vehicle.hpp Everything to query and build vehicles. */ + +#ifndef AI_VEHICLE_HPP +#define AI_VEHICLE_HPP + +#include "ai_object.hpp" +#include "ai_error.hpp" +#include "ai_road.hpp" +#include "ai_order.hpp" + +/** + * Class that handles all vehicle related functions. + */ +class AIVehicle : public AIObject { +public: + static const char *GetClassName() { return "AIVehicle"; } + + /** + * All vehicle related error messages. + */ + enum ErrorMessages { + /** Base for vehicle related errors */ + ERR_VEHICLE_BASE = AIError::ERR_CAT_VEHICLE << AIError::ERR_CAT_BIT_SIZE, + + /** Too many vehicles in the game, can't build any more. */ + ERR_VEHICLE_TOO_MANY, // [STR_00E1_TOO_MANY_VEHICLES_IN_GAME] + + /** Vehicle is not available */ + ERR_VEHICLE_NOT_AVAILABLE, // [STR_AIRCRAFT_NOT_AVAILABLE, STR_ROAD_VEHICLE_NOT_AVAILABLE, STR_SHIP_NOT_AVAILABLE, STR_RAIL_VEHICLE_NOT_AVAILABLE] + + /** Vehicle can't be build due to game settigns */ + ERR_VEHICLE_BUILD_DISABLED, // [STR_A008_CAN_T_BUILD_AIRCRAFT, STR_980D_CAN_T_BUILD_SHIP, STR_9009_CAN_T_BUILD_ROAD_VEHICLE, STR_882B_CAN_T_BUILD_RAILROAD_VEHICLE] + + /** Vehicle can't be build in the selected depot */ + ERR_VEHICLE_WRONG_DEPOT, // [STR_DEPOT_WRONG_DEPOT_TYPE] + + /** Vehicle can't return to the depot */ + ERR_VEHICLE_CANNOT_SEND_TO_DEPOT, // [STR_8830_CAN_T_SEND_TRAIN_TO_DEPOT, STR_9018_CAN_T_SEND_VEHICLE_TO_DEPOT, STR_9819_CAN_T_SEND_SHIP_TO_DEPOT, STR_A012_CAN_T_SEND_AIRCRAFT_TO] + + /** Vehicle can't start / stop */ + ERR_VEHICLE_CANNOT_START_STOP, // [STR_883B_CAN_T_STOP_START_TRAIN, STR_9015_CAN_T_STOP_START_ROAD_VEHICLE, STR_9818_CAN_T_STOP_START_SHIP, STR_A016_CAN_T_STOP_START_AIRCRAFT] + + /** Vehicle can't turn */ + ERR_VEHICLE_CANNOT_TURN, // [STR_8869_CAN_T_REVERSE_DIRECTION, STR_9033_CAN_T_MAKE_VEHICLE_TURN] + + /** Vehicle can't be refit */ + ERR_VEHICLE_CANNOT_REFIT, // [STR_RAIL_CAN_T_REFIT_VEHICLE, STR_REFIT_ROAD_VEHICLE_CAN_T, STR_9841_CAN_T_REFIT_SHIP, STR_A042_CAN_T_REFIT_AIRCRAFT] + + /** Vehicle is destroyed */ + ERR_VEHICLE_IS_DESTROYED, // [STR_CAN_T_REFIT_DESTROYED_VEHICLE, STR_CAN_T_SELL_DESTROYED_VEHICLE] + + /** Vehicle is not in a depot */ + ERR_VEHICLE_NOT_IN_DEPOT, // [STR_A01B_AIRCRAFT_MUST_BE_STOPPED, STR_9013_MUST_BE_STOPPED_INSIDE, STR_TRAIN_MUST_BE_STOPPED, STR_980B_SHIP_MUST_BE_STOPPED_IN] + + /** Vehicle is flying */ + ERR_VEHICLE_IN_FLIGHT, // [STR_A017_AIRCRAFT_IS_IN_FLIGHT] + + /** Vehicle is without power */ + ERR_VEHCILE_NO_POWER, // [STR_TRAIN_START_NO_CATENARY] + + }; + + /** + * The type of a vehicle available in the game. Trams for example are + * road vehicles, as maglev is a rail vehicle. + */ + enum VehicleType { + /* Order IS important, as it now matches the internal state of the game for vehicle type */ + VEHICLE_RAIL, //!< Rail type vehicle. + VEHICLE_ROAD, //!< Road type vehicle (bus / truck). + VEHICLE_WATER, //!< Water type vehicle. + VEHICLE_AIR, //!< Air type vehicle. + VEHICLE_INVALID = 0xFF, //!< Invalid vehicle type. + }; + + /** + * The different states a vehicle can be in. + */ + enum VehicleState { + VS_RUNNING, //!< The vehicle is currently running. + VS_STOPPED, //!< The vehicle is stopped manually. + VS_IN_DEPOT, //!< The vehicle is stopped in the depot. + VS_AT_STATION, //!< The vehicle is stopped at a station and is currently loading or unloading. + VS_BROKEN, //!< The vehicle has broken down and will start running again in a while. + VS_CRASHED, //!< The vehicle is crashed (and will never run again). + + VS_INVALID = 0xFF, //!< An invalid vehicle state. + }; + + /** + * Checks whether the given vehicle is valid and owned by you. + * @param vehicle_id The vehicle to check. + * @return True if and only if the vehicle is valid. + */ + static bool IsValidVehicle(VehicleID vehicle_id); + + /** + * Get the number of wagons a vehicle has. + * @param vehicle_id The vehicle to get the number of wagons from. + * @pre IsValidVehicle(vehicle_id). + * @return The number of wagons the vehicle has. + */ + static int32 GetNumWagons(VehicleID vehicle_id); + + /** + * Set the name of a vehicle. + * @param vehicle_id The vehicle to set the name for. + * @param name The name for the vehicle. + * @pre IsValidVehicle(vehicle_id). + * @pre 'name' must have at least one character. + * @pre 'name' must have at most 30 characters. + * @exception AIError::ERR_NAME_IS_NOT_UNIQUE + * @return True if and only if the name was changed. + */ + static bool SetName(VehicleID vehicle_id, const char *name); + + /** + * Get the name of a vehicle. + * @param vehicle_id The vehicle to get the name of. + * @pre IsValidVehicle(vehicle_id). + * @return The name the vehicle has. + */ + static const char *GetName(VehicleID vehicle_id); + + /** + * Get the current location of a vehicle. + * @param vehicle_id The vehicle to get the location of. + * @pre IsValidVehicle(vehicle_id). + * @return The tile the vehicle is currently on. + */ + static TileIndex GetLocation(VehicleID vehicle_id); + + /** + * Get the engine-type of a vehicle. + * @param vehicle_id The vehicle to get the engine-type of. + * @pre IsValidVehicle(vehicle_id). + * @return The engine type the vehicle has. + */ + static EngineID GetEngineType(VehicleID vehicle_id); + + /** + * Get the engine-type of a wagon. + * @param vehicle_id The vehicle to get the engine-type of. + * @param wagon The wagon in the vehicle to get the engine-type of. + * @pre IsValidVehicle(vehicle_id). + * @pre wagon < GetNumWagons(vehicle_id). + * @return The engine type the vehicle has. + */ + static EngineID GetWagonEngineType(VehicleID vehicle_id, int wagon); + + /** + * Get the unitnumber of a vehicle. + * @param vehicle_id The vehicle to get the unitnumber of. + * @pre IsValidVehicle(vehicle_id). + * @return The unitnumber the vehicle has. + */ + static int32 GetUnitNumber(VehicleID vehicle_id); + + /** + * Get the current age of a vehicle. + * @param vehicle_id The vehicle to get the age of. + * @pre IsValidVehicle(vehicle_id). + * @return The current age the vehicle has. + * @note The age is in days. + */ + static int32 GetAge(VehicleID vehicle_id); + + /** + * Get the current age of a second (or third, etc.) engine in a train vehicle. + * @param vehicle_id The vehicle to get the age of. + * @param wagon The wagon in the vehicle to get the age of. + * @pre IsValidVehicle(vehicle_id). + * @pre wagon < GetNumWagons(vehicle_id). + * @return The current age the vehicle has. + * @note The age is in days. + */ + static int32 GetWagonAge(VehicleID vehicle_id, int wagon); + + /** + * Get the maximum age of a vehicle. + * @param vehicle_id The vehicle to get the age of. + * @pre IsValidVehicle(vehicle_id). + * @return The maximum age the vehicle has. + * @note The age is in days. + */ + static int32 GetMaxAge(VehicleID vehicle_id); + + /** + * Get the age a vehicle has left (maximum - current). + * @param vehicle_id The vehicle to get the age of. + * @pre IsValidVehicle(vehicle_id). + * @return The age the vehicle has left. + * @note The age is in days. + */ + static int32 GetAgeLeft(VehicleID vehicle_id); + + /** + * Get the current speed of a vehicle. + * @param vehicle_id The vehicle to get the age of. + * @pre IsValidVehicle(vehicle_id). + * @return The current speed of the vehicle. + * @note Speed is in km/h. + */ + static int32 GetCurrentSpeed(VehicleID vehicle_id); + + /** + * Get the current state of a vehicle. + * @param vehicle_id The vehicle to get the state of. + * @pre IsValidVehicle(vehicle_id). + * @return The current state of the vehicle. + */ + static VehicleState GetState(VehicleID vehicle_id); + + /** + * Get the running cost of this vehicle. + * @param vehicle_id The vehicle to get the age of. + * @pre IsValidVehicle(vehicle_id). + * @return The running cost of the vehicle per year. + * @note Cost is per year; divide by 364 to get per day. + * @note This is not equal to AIEngine::GetRunningCost for Trains, because + * wagons and second engines can add up in the calculation too. + */ + static Money GetRunningCost(VehicleID vehicle_id); + + /** + * Get the current profit of a vehicle. + * @param vehicle_id The vehicle to get the profit of. + * @pre IsValidVehicle(vehicle_id). + * @return The current profit the vehicle has. + */ + static Money GetProfitThisYear(VehicleID vehicle_id); + + /** + * Get the profit of last year of a vehicle. + * @param vehicle_id The vehicle to get the profit of. + * @pre IsValidVehicle(vehicle_id). + * @return The profit the vehicle had last year. + */ + static Money GetProfitLastYear(VehicleID vehicle_id); + + + /** + * Get the current value of a vehicle. + * @param vehicle_id The vehicle to get the value of. + * @pre IsValidVehicle(vehicle_id). + * @return The value the vehicle currently has (the amount you should get + * when you would sell the vehicle right now). + */ + static Money GetCurrentValue(VehicleID vehicle_id); + + /** + * Get the type of vehicle. + * @param vehicle_id The vehicle to get the type of. + * @pre IsValidVehicle(vehicle_id). + * @return The vehicle type. + */ + static AIVehicle::VehicleType GetVehicleType(VehicleID vehicle_id); + + /** + * Get the RoadType of the vehicle. + * @param vehicle_id The vehicle to get the RoadType of. + * @pre IsValidVehicle(vehicle_id). + * @pre GetVehicleType(vehicle_id) == VEHICLE_ROAD. + * @return The RoadType the vehicle has. + */ + static AIRoad::RoadType GetRoadType(VehicleID vehicle_id); + + /** + * Check if a vehicle is in a depot. + * @param vehicle_id The vehicle to check. + * @pre IsValidVehicle(vehicle_id). + * @return True if and only if the vehicle is in a depot. + */ + static bool IsInDepot(VehicleID vehicle_id); + + /** + * Check if a vehicle is in a depot and stopped. + * @param vehicle_id The vehicle to check. + * @pre IsValidVehicle(vehicle_id). + * @return True if and only if the vehicle is in a depot and stopped. + */ + static bool IsStoppedInDepot(VehicleID vehicle_id); + + /** + * Builds a vehicle with the given engine at the given depot. + * @param depot The depot where the vehicle will be build. + * @param engine_id The engine to use for this vehicle. + * @pre The tile at depot has a depot that can build the engine and + * is owned by you. + * @pre IsValidEngine(engine_id). + * @exception AIVehicle::ERR_VEHICLE_TOO_MANY + * @exception AIVehicle::ERR_VEHICLE_BUILD_DISABLED + * @exception AIVehicle::ERR_VEHICLE_WRONG_DEPOT + * @return The VehicleID of the new vehicle, or an invalid VehicleID when + * it failed. Check the return value using IsValidVehicle. In test-mode + * 0 is returned if it was successful; any other value indicates failure. + * @note In Test Mode it means you can't assign orders yet to this vehicle, + * as the vehicle isn't really built yet. Build it for real first before + * assigning orders. + */ + static VehicleID BuildVehicle(TileIndex depot, EngineID engine_id); + + /** + * Clones a vehicle at the given depot, copying or cloning it's orders. + * @param depot The depot where the vehicle will be build. + * @param vehicle_id The vehicle to use as example for the new vehicle. + * @param share_orders Should the orders be copied or shared? + * @pre The tile 'depot' has a depot on it, allowing 'vehicle_id'-type vehicles. + * @pre IsValidVehicle(vehicle_id). + * @exception AIVehicle::ERR_VEHICLE_TOO_MANY + * @exception AIVehicle::ERR_VEHICLE_BUILD_DISABLED + * @exception AIVehicle::ERR_VEHICLE_WRONG_DEPOT + * @return The VehicleID of the new vehicle, or an invalid VehicleID when + * it failed. Check the return value using IsValidVehicle. In test-mode + * 0 is returned if it was successful; any other value indicates failure. + */ + static VehicleID CloneVehicle(TileIndex depot, VehicleID vehicle_id, bool share_orders); + + /** + * Move a wagon after another wagon. + * @param source_vehicle_id The vehicle to move a wagon away from. + * @param source_wagon The wagon in source_vehicle to move. + * @param move_attached_wagons Also move all wagons attached to the wagon to move. + * @param dest_vehicle_id The vehicle to move the wagon to, or -1 to create a new vehicle. + * @param dest_wagon The wagon in dest_vehicle to place source_wagon after. + * @pre IsValidVehicle(source_vehicle_id). + * @pre source_wagon < GetNumWagons(source_vehicle_id). + * @pre dest_vehicle_id == -1 || (IsValidVehicle(dest_vehicle_id) && dest_wagon < GetNumWagons(dest_vehicle_id)). + * @pre GetVehicleType(source_vehicle_id) == VEHICLE_RAIL. + * @pre dest_vehicle_id == -1 || GetVehicleType(dest_vehicle_id) == VEHICLE_RAIL. + * @return Whether or not moving the wagon(s) succeeded. + */ + static bool MoveWagon(VehicleID source_vehicle_id, int source_wagon, bool move_attached_wagons, int dest_vehicle_id, int dest_wagon); + + /** + * Gets the capacity of the given vehicle when refited to the given cargo type. + * @param vehicle_id The vehicle to refit. + * @param cargo The cargo to refit to. + * @pre IsValidVehicle(vehicle_id). + * @pre AICargo::IsValidCargo(cargo). + * @pre You must own the vehicle. + * @pre The vehicle must be stopped in the depot. + * @return The capacity the vehicle will have when refited. + */ + static int GetRefitCapacity(VehicleID vehicle_id, CargoID cargo); + + /** + * Refits a vehicle to the given cargo type. + * @param vehicle_id The vehicle to refit. + * @param cargo The cargo to refit to. + * @pre IsValidVehicle(vehicle_id). + * @pre AICargo::IsValidCargo(cargo). + * @pre You must own the vehicle. + * @pre The vehicle must be stopped in the depot. + * @exception AIVehicle::ERR_VEHICLE_CANNOT_REFIT + * @exception AIVehicle::ERR_VEHICLE_IS_DESTROYED + * @exception AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT + * @return True if and only if the refit succeeded. + */ + static bool RefitVehicle(VehicleID vehicle_id, CargoID cargo); + + /** + * Sells the given vehicle. + * @param vehicle_id The vehicle to sell. + * @pre IsValidVehicle(vehicle_id). + * @pre You must own the vehicle. + * @pre The vehicle must be stopped in the depot. + * @exception AIVehicle::ERR_VEHICLE_IS_DESTROYED + * @exception AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT + * @return True if and only if the vehicle has been sold. + */ + static bool SellVehicle(VehicleID vehicle_id); + + /** + * Sells the given wagon from the vehicle. + * @param vehicle_id The vehicle to sell a wagon from. + * @param wagon The wagon to sell. + * @param sell_attached_wagons Sell all wagons attached to the one we want to sell. + * @pre IsValidVehicle(vehicle_id). + * @pre wagon < GetNumWagons(vehicle_id). + * @pre You must own the vehicle. + * @pre The vehicle must be stopped in the depot. + * @exception AIVehicle::ERR_VEHICLE_IS_DESTROYED + * @exception AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT + * @return True if and only if the wagon(s) has been sold. + */ + static bool SellWagon(VehicleID vehicle_id, int wagon, bool sell_attached_wagons); + + /** + * Sends the given vehicle to a depot. + * @param vehicle_id The vehicle to send to a depot. + * @pre IsValidVehicle(vehicle_id). + * @exception AIVehicle::ERR_VEHICLE_CANNOT_SEND_TO_DEPOT + * @return True if and only if the vehicle has been sent to a depot. + */ + static bool SendVehicleToDepot(VehicleID vehicle_id); + + /** + * Starts or stops the given vehicle depending on the current state. + * @param vehicle_id The vehicle to start/stop. + * @pre IsValidVehicle(vehicle_id). + * @exception AIVehicle::ERR_VEHICLE_CANNOT_START_STOP + * @exception (For aircraft only): AIVehicle::ERR_VEHICLE_IN_FLIGHT + * @exception (For trains only): AIVehicle::ERR_VEHICLE_NO_POWER + * @return True if and only if the vehicle has been started or stopped. + */ + static bool StartStopVehicle(VehicleID vehicle_id); + + /** + * Skips the current order of the given vehicle. + * @param vehicle_id The vehicle to skip the order for. + * @param order_position The selected order to which we want to skip. + * @pre IsValidVehicleOrder(vehicle_id, order_position). + * @return True if and only if the order has been skipped. + */ + static bool SkipToVehicleOrder(VehicleID vehicle_id, AIOrder::OrderPosition order_position); + + /** + * Turn the given vehicle so it'll drive the other way. + * @param vehicle_id The vehicle to turn. + * @pre IsValidVehicle(vehicle_id). + * @pre GetVehicleType(vehicle_id) == VEHICLE_ROAD || GetVehicleType(vehicle_id) == VEHICLE_RAIL. + * @return True if and only if the vehicle has started to turn. + * @note Vehicles cannot always be reversed. For example busses and trucks need to be running + * and not be inside a depot. + */ + static bool ReverseVehicle(VehicleID vehicle_id); + + /** + * Get the maximum amount of a specific cargo the given vehicle can transport. + * @param vehicle_id The vehicle to get the capacity of. + * @param cargo The cargo to get the capacity for. + * @pre IsValidVehicle(vehicle_id). + * @pre AICargo::IsValidCargo(cargo). + * @return The maximum amount of the given cargo the vehicle can transport. + */ + static int32 GetCapacity(VehicleID vehicle_id, CargoID cargo); + + /** + * Get the length of a the total vehicle in 1/16's of a tile. + * @param vehicle_id The vehicle to get the length of. + * @pre IsValidVehicle(vehicle_id). + * @pre GetVehicleType(vehicle_id) == AIVehicle.VEHICLE_ROAD || GetVehicleType(vehicle_id) == AIVehicle.VEHICLE_RAIL. + * @return The length of the engine. + */ + static int GetLength(VehicleID vehicle_id); + + /** + * Get the amount of a specific cargo the given vehicle transports. + * @param vehicle_id The vehicle to get the load amount of. + * @param cargo The cargo to get the load amount for. + * @pre IsValidVehicle(vehicle_id). + * @pre AICargo::IsValidCargo(cargo). + * @return The amount of the given cargo the vehicle currently transports. + */ + static int32 GetCargoLoad(VehicleID vehicle_id, CargoID cargo); + + /** + * Get the group of a given vehicle. + * @param vehicle_id The vehicle to get the group from. + * @return The group of the given vehicle. + */ + static GroupID GetGroupID(VehicleID vehicle_id); + + /** + * Check if the vehicle is articulated. + * @param vehicle_id The vehicle to check. + * @pre IsValidVehicle(vehicle_id). + * @pre GetVehicleType(vehicle_id) == VEHICLE_ROAD || GetVehicleType(vehicle_id) == VEHICLE_RAIL. + * @return True if the vehicle is articulated. + */ + static bool IsArticulated(VehicleID vehicle_id); +}; + +#endif /* AI_VEHICLE_HPP */ diff --git a/src/ai/api/ai_vehicle.hpp.sq b/src/ai/api/ai_vehicle.hpp.sq new file mode 100644 index 000000000..87dce4893 --- /dev/null +++ b/src/ai/api/ai_vehicle.hpp.sq @@ -0,0 +1,141 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_vehicle.hpp" + +namespace SQConvert { + /* Allow enums to be used as Squirrel parameters */ + template <> AIVehicle::ErrorMessages GetParam(ForceType<AIVehicle::ErrorMessages>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIVehicle::ErrorMessages)tmp; } + template <> int Return<AIVehicle::ErrorMessages>(HSQUIRRELVM vm, AIVehicle::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIVehicle::VehicleType GetParam(ForceType<AIVehicle::VehicleType>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIVehicle::VehicleType)tmp; } + template <> int Return<AIVehicle::VehicleType>(HSQUIRRELVM vm, AIVehicle::VehicleType res) { sq_pushinteger(vm, (int32)res); return 1; } + template <> AIVehicle::VehicleState GetParam(ForceType<AIVehicle::VehicleState>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIVehicle::VehicleState)tmp; } + template <> int Return<AIVehicle::VehicleState>(HSQUIRRELVM vm, AIVehicle::VehicleState res) { sq_pushinteger(vm, (int32)res); return 1; } + + /* Allow AIVehicle to be used as Squirrel parameter */ + template <> AIVehicle *GetParam(ForceType<AIVehicle *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIVehicle *)instance; } + template <> AIVehicle &GetParam(ForceType<AIVehicle &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicle *)instance; } + template <> const AIVehicle *GetParam(ForceType<const AIVehicle *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIVehicle *)instance; } + template <> const AIVehicle &GetParam(ForceType<const AIVehicle &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicle *)instance; } + template <> int Return<AIVehicle *>(HSQUIRRELVM vm, AIVehicle *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicle", res, NULL, DefSQDestructorCallback<AIVehicle>); return 1; } +}; // namespace SQConvert + +void SQAIVehicle_Register(Squirrel *engine) { + DefSQClass <AIVehicle> SQAIVehicle("AIVehicle"); + SQAIVehicle.PreRegister(engine); + SQAIVehicle.AddConstructor<void (AIVehicle::*)(), 1>(engine, "x"); + + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_BASE, "ERR_VEHICLE_BASE"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_TOO_MANY, "ERR_VEHICLE_TOO_MANY"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_NOT_AVAILABLE, "ERR_VEHICLE_NOT_AVAILABLE"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_BUILD_DISABLED, "ERR_VEHICLE_BUILD_DISABLED"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_WRONG_DEPOT, "ERR_VEHICLE_WRONG_DEPOT"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_CANNOT_SEND_TO_DEPOT, "ERR_VEHICLE_CANNOT_SEND_TO_DEPOT"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_CANNOT_START_STOP, "ERR_VEHICLE_CANNOT_START_STOP"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_CANNOT_TURN, "ERR_VEHICLE_CANNOT_TURN"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_CANNOT_REFIT, "ERR_VEHICLE_CANNOT_REFIT"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_IS_DESTROYED, "ERR_VEHICLE_IS_DESTROYED"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT, "ERR_VEHICLE_NOT_IN_DEPOT"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHICLE_IN_FLIGHT, "ERR_VEHICLE_IN_FLIGHT"); + SQAIVehicle.DefSQConst(engine, AIVehicle::ERR_VEHCILE_NO_POWER, "ERR_VEHCILE_NO_POWER"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VEHICLE_RAIL, "VEHICLE_RAIL"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VEHICLE_ROAD, "VEHICLE_ROAD"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VEHICLE_WATER, "VEHICLE_WATER"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VEHICLE_AIR, "VEHICLE_AIR"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VEHICLE_INVALID, "VEHICLE_INVALID"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VS_RUNNING, "VS_RUNNING"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VS_STOPPED, "VS_STOPPED"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VS_IN_DEPOT, "VS_IN_DEPOT"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VS_AT_STATION, "VS_AT_STATION"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VS_BROKEN, "VS_BROKEN"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VS_CRASHED, "VS_CRASHED"); + SQAIVehicle.DefSQConst(engine, AIVehicle::VS_INVALID, "VS_INVALID"); + + AIError::RegisterErrorMap(STR_00E1_TOO_MANY_VEHICLES_IN_GAME, AIVehicle::ERR_VEHICLE_TOO_MANY); + AIError::RegisterErrorMap(STR_AIRCRAFT_NOT_AVAILABLE, AIVehicle::ERR_VEHICLE_NOT_AVAILABLE); + AIError::RegisterErrorMap(STR_ROAD_VEHICLE_NOT_AVAILABLE, AIVehicle::ERR_VEHICLE_NOT_AVAILABLE); + AIError::RegisterErrorMap(STR_SHIP_NOT_AVAILABLE, AIVehicle::ERR_VEHICLE_NOT_AVAILABLE); + AIError::RegisterErrorMap(STR_RAIL_VEHICLE_NOT_AVAILABLE, AIVehicle::ERR_VEHICLE_NOT_AVAILABLE); + AIError::RegisterErrorMap(STR_A008_CAN_T_BUILD_AIRCRAFT, AIVehicle::ERR_VEHICLE_BUILD_DISABLED); + AIError::RegisterErrorMap(STR_980D_CAN_T_BUILD_SHIP, AIVehicle::ERR_VEHICLE_BUILD_DISABLED); + AIError::RegisterErrorMap(STR_9009_CAN_T_BUILD_ROAD_VEHICLE, AIVehicle::ERR_VEHICLE_BUILD_DISABLED); + AIError::RegisterErrorMap(STR_882B_CAN_T_BUILD_RAILROAD_VEHICLE, AIVehicle::ERR_VEHICLE_BUILD_DISABLED); + AIError::RegisterErrorMap(STR_DEPOT_WRONG_DEPOT_TYPE, AIVehicle::ERR_VEHICLE_WRONG_DEPOT); + AIError::RegisterErrorMap(STR_8830_CAN_T_SEND_TRAIN_TO_DEPOT, AIVehicle::ERR_VEHICLE_CANNOT_SEND_TO_DEPOT); + AIError::RegisterErrorMap(STR_9018_CAN_T_SEND_VEHICLE_TO_DEPOT, AIVehicle::ERR_VEHICLE_CANNOT_SEND_TO_DEPOT); + AIError::RegisterErrorMap(STR_9819_CAN_T_SEND_SHIP_TO_DEPOT, AIVehicle::ERR_VEHICLE_CANNOT_SEND_TO_DEPOT); + AIError::RegisterErrorMap(STR_A012_CAN_T_SEND_AIRCRAFT_TO, AIVehicle::ERR_VEHICLE_CANNOT_SEND_TO_DEPOT); + AIError::RegisterErrorMap(STR_883B_CAN_T_STOP_START_TRAIN, AIVehicle::ERR_VEHICLE_CANNOT_START_STOP); + AIError::RegisterErrorMap(STR_9015_CAN_T_STOP_START_ROAD_VEHICLE, AIVehicle::ERR_VEHICLE_CANNOT_START_STOP); + AIError::RegisterErrorMap(STR_9818_CAN_T_STOP_START_SHIP, AIVehicle::ERR_VEHICLE_CANNOT_START_STOP); + AIError::RegisterErrorMap(STR_A016_CAN_T_STOP_START_AIRCRAFT, AIVehicle::ERR_VEHICLE_CANNOT_START_STOP); + AIError::RegisterErrorMap(STR_8869_CAN_T_REVERSE_DIRECTION, AIVehicle::ERR_VEHICLE_CANNOT_TURN); + AIError::RegisterErrorMap(STR_9033_CAN_T_MAKE_VEHICLE_TURN, AIVehicle::ERR_VEHICLE_CANNOT_TURN); + AIError::RegisterErrorMap(STR_RAIL_CAN_T_REFIT_VEHICLE, AIVehicle::ERR_VEHICLE_CANNOT_REFIT); + AIError::RegisterErrorMap(STR_REFIT_ROAD_VEHICLE_CAN_T, AIVehicle::ERR_VEHICLE_CANNOT_REFIT); + AIError::RegisterErrorMap(STR_9841_CAN_T_REFIT_SHIP, AIVehicle::ERR_VEHICLE_CANNOT_REFIT); + AIError::RegisterErrorMap(STR_A042_CAN_T_REFIT_AIRCRAFT, AIVehicle::ERR_VEHICLE_CANNOT_REFIT); + AIError::RegisterErrorMap(STR_CAN_T_REFIT_DESTROYED_VEHICLE, AIVehicle::ERR_VEHICLE_IS_DESTROYED); + AIError::RegisterErrorMap(STR_CAN_T_SELL_DESTROYED_VEHICLE, AIVehicle::ERR_VEHICLE_IS_DESTROYED); + AIError::RegisterErrorMap(STR_A01B_AIRCRAFT_MUST_BE_STOPPED, AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT); + AIError::RegisterErrorMap(STR_9013_MUST_BE_STOPPED_INSIDE, AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT); + AIError::RegisterErrorMap(STR_TRAIN_MUST_BE_STOPPED, AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT); + AIError::RegisterErrorMap(STR_980B_SHIP_MUST_BE_STOPPED_IN, AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT); + AIError::RegisterErrorMap(STR_A017_AIRCRAFT_IS_IN_FLIGHT, AIVehicle::ERR_VEHICLE_IN_FLIGHT); + AIError::RegisterErrorMap(STR_TRAIN_START_NO_CATENARY, AIVehicle::ERR_VEHCILE_NO_POWER); + + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_TOO_MANY, "ERR_VEHICLE_TOO_MANY"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_NOT_AVAILABLE, "ERR_VEHICLE_NOT_AVAILABLE"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_BUILD_DISABLED, "ERR_VEHICLE_BUILD_DISABLED"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_WRONG_DEPOT, "ERR_VEHICLE_WRONG_DEPOT"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_CANNOT_SEND_TO_DEPOT, "ERR_VEHICLE_CANNOT_SEND_TO_DEPOT"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_CANNOT_START_STOP, "ERR_VEHICLE_CANNOT_START_STOP"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_CANNOT_TURN, "ERR_VEHICLE_CANNOT_TURN"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_CANNOT_REFIT, "ERR_VEHICLE_CANNOT_REFIT"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_IS_DESTROYED, "ERR_VEHICLE_IS_DESTROYED"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT, "ERR_VEHICLE_NOT_IN_DEPOT"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_IN_FLIGHT, "ERR_VEHICLE_IN_FLIGHT"); + AIError::RegisterErrorMapString(AIVehicle::ERR_VEHCILE_NO_POWER, "ERR_VEHCILE_NO_POWER"); + + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetClassName, "GetClassName", 1, "x"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::IsValidVehicle, "IsValidVehicle", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetNumWagons, "GetNumWagons", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::SetName, "SetName", 3, "xis"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetName, "GetName", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetLocation, "GetLocation", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetEngineType, "GetEngineType", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetWagonEngineType, "GetWagonEngineType", 3, "xii"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetUnitNumber, "GetUnitNumber", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetAge, "GetAge", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetWagonAge, "GetWagonAge", 3, "xii"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetMaxAge, "GetMaxAge", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetAgeLeft, "GetAgeLeft", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetCurrentSpeed, "GetCurrentSpeed", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetState, "GetState", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetRunningCost, "GetRunningCost", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetProfitThisYear, "GetProfitThisYear", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetProfitLastYear, "GetProfitLastYear", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetCurrentValue, "GetCurrentValue", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetVehicleType, "GetVehicleType", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetRoadType, "GetRoadType", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::IsInDepot, "IsInDepot", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::IsStoppedInDepot, "IsStoppedInDepot", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::BuildVehicle, "BuildVehicle", 3, "xii"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::CloneVehicle, "CloneVehicle", 4, "xiib"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::MoveWagon, "MoveWagon", 6, "xiibii"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetRefitCapacity, "GetRefitCapacity", 3, "xii"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::RefitVehicle, "RefitVehicle", 3, "xii"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::SellVehicle, "SellVehicle", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::SellWagon, "SellWagon", 4, "xiib"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::SendVehicleToDepot, "SendVehicleToDepot", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::StartStopVehicle, "StartStopVehicle", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::SkipToVehicleOrder, "SkipToVehicleOrder", 3, "xii"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::ReverseVehicle, "ReverseVehicle", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetCapacity, "GetCapacity", 3, "xii"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetLength, "GetLength", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetCargoLoad, "GetCargoLoad", 3, "xii"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetGroupID, "GetGroupID", 2, "xi"); + SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::IsArticulated, "IsArticulated", 2, "xi"); + + SQAIVehicle.PostRegister(engine); +} diff --git a/src/ai/api/ai_vehiclelist.cpp b/src/ai/api/ai_vehiclelist.cpp new file mode 100644 index 000000000..127ac77e9 --- /dev/null +++ b/src/ai/api/ai_vehiclelist.cpp @@ -0,0 +1,37 @@ +/* $Id$ */ + +/** @file ai_vehiclelist.cpp Implementation of AIVehicleList and friends. */ + +#include "ai_vehiclelist.hpp" +#include "ai_station.hpp" +#include "../../openttd.h" +#include "../../company_func.h" +#include "../../vehicle_base.h" + +AIVehicleList::AIVehicleList() +{ + Vehicle *v; + FOR_ALL_VEHICLES(v) { + if (v->owner == _current_company && v->IsPrimaryVehicle()) this->AddItem(v->index); + } +} + +AIVehicleList_Station::AIVehicleList_Station(StationID station_id) +{ + if (!AIStation::IsValidStation(station_id)) return; + + Vehicle *v; + + FOR_ALL_VEHICLES(v) { + if (v->owner == _current_company && v->IsPrimaryVehicle()) { + const Order *order; + + FOR_VEHICLE_ORDERS(v, order) { + if (order->IsType(OT_GOTO_STATION) && order->GetDestination() == station_id) { + this->AddItem(v->index); + break; + } + } + } + } +} diff --git a/src/ai/api/ai_vehiclelist.hpp b/src/ai/api/ai_vehiclelist.hpp new file mode 100644 index 000000000..0e91d75bc --- /dev/null +++ b/src/ai/api/ai_vehiclelist.hpp @@ -0,0 +1,34 @@ +/* $Id$ */ + +/** @file ai_vehiclelist.hpp List all the vehicles (you own). */ + +#ifndef AI_VEHICLELIST_HPP +#define AI_VEHICLELIST_HPP + +#include "ai_abstractlist.hpp" + +/** + * Creates a list of vehicles of which you are the owner. + * @ingroup AIList + */ +class AIVehicleList : public AIAbstractList { +public: + static const char *GetClassName() { return "AIVehicleList"; } + AIVehicleList(); +}; + +/** + * Creates a list of vehicles that have orders to a given station. + * @ingroup AIList + */ +class AIVehicleList_Station : public AIAbstractList { +public: + static const char *GetClassName() { return "AIVehicleList_Station"; } + + /** + * @param station_id The station to get the list of vehicles that have orders to him from. + */ + AIVehicleList_Station(StationID station_id); +}; + +#endif /* AI_VEHICLELIST_HPP */ diff --git a/src/ai/api/ai_vehiclelist.hpp.sq b/src/ai/api/ai_vehiclelist.hpp.sq new file mode 100644 index 000000000..5a5f930cb --- /dev/null +++ b/src/ai/api/ai_vehiclelist.hpp.sq @@ -0,0 +1,42 @@ +/* $Id$ */ +/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */ + +#include "ai_vehiclelist.hpp" + +namespace SQConvert { + /* Allow AIVehicleList to be used as Squirrel parameter */ + template <> AIVehicleList *GetParam(ForceType<AIVehicleList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIVehicleList *)instance; } + template <> AIVehicleList &GetParam(ForceType<AIVehicleList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList *)instance; } + template <> const AIVehicleList *GetParam(ForceType<const AIVehicleList *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIVehicleList *)instance; } + template <> const AIVehicleList &GetParam(ForceType<const AIVehicleList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList *)instance; } + template <> int Return<AIVehicleList *>(HSQUIRRELVM vm, AIVehicleList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList", res, NULL, DefSQDestructorCallback<AIVehicleList>); return 1; } +}; // namespace SQConvert + +void SQAIVehicleList_Register(Squirrel *engine) { + DefSQClass <AIVehicleList> SQAIVehicleList("AIVehicleList"); + SQAIVehicleList.PreRegister(engine, "AIAbstractList"); + SQAIVehicleList.AddConstructor<void (AIVehicleList::*)(), 1>(engine, "x"); + + SQAIVehicleList.DefSQStaticMethod(engine, &AIVehicleList::GetClassName, "GetClassName", 1, "x"); + + SQAIVehicleList.PostRegister(engine); +} + +namespace SQConvert { + /* Allow AIVehicleList_Station to be used as Squirrel parameter */ + template <> AIVehicleList_Station *GetParam(ForceType<AIVehicleList_Station *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIVehicleList_Station *)instance; } + template <> AIVehicleList_Station &GetParam(ForceType<AIVehicleList_Station &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_Station *)instance; } + template <> const AIVehicleList_Station *GetParam(ForceType<const AIVehicleList_Station *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIVehicleList_Station *)instance; } + template <> const AIVehicleList_Station &GetParam(ForceType<const AIVehicleList_Station &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_Station *)instance; } + template <> int Return<AIVehicleList_Station *>(HSQUIRRELVM vm, AIVehicleList_Station *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_Station", res, NULL, DefSQDestructorCallback<AIVehicleList_Station>); return 1; } +}; // namespace SQConvert + +void SQAIVehicleList_Station_Register(Squirrel *engine) { + DefSQClass <AIVehicleList_Station> SQAIVehicleList_Station("AIVehicleList_Station"); + SQAIVehicleList_Station.PreRegister(engine, "AIAbstractList"); + SQAIVehicleList_Station.AddConstructor<void (AIVehicleList_Station::*)(StationID station_id), 2>(engine, "xi"); + + SQAIVehicleList_Station.DefSQStaticMethod(engine, &AIVehicleList_Station::GetClassName, "GetClassName", 1, "x"); + + SQAIVehicleList_Station.PostRegister(engine); +} diff --git a/src/ai/api/squirrel_export.awk b/src/ai/api/squirrel_export.awk new file mode 100644 index 000000000..877586722 --- /dev/null +++ b/src/ai/api/squirrel_export.awk @@ -0,0 +1,385 @@ +# $Id$ +# +# Awk script to automatically generate the code needed +# to export the AI API to Squirrel. +# +# Note that arrays are 1 based... +# + +# Simple insertion sort. +function array_sort(ARRAY, ELEMENTS, temp, i, j) { + for (i = 2; i <= ELEMENTS; i++) + for (j = i; ARRAY[j - 1] > ARRAY[j]; --j) { + temp = ARRAY[j] + ARRAY[j] = ARRAY[j - 1] + ARRAY[j - 1] = temp + } + return +} + +function dump_class_templates(name) { + print " template <> " name " *GetParam(ForceType<" name " *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (" name " *)instance; }" + print " template <> " name " &GetParam(ForceType<" name " &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(" name " *)instance; }" + print " template <> const " name " *GetParam(ForceType<const " name " *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (" name " *)instance; }" + print " template <> const " name " &GetParam(ForceType<const " name " &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(" name " *)instance; }" + if (name == "AIEvent") { + print " template <> int Return<" name " *>(HSQUIRRELVM vm, " name " *res) { if (res == NULL) { sq_pushnull(vm); return 1; } Squirrel::CreateClassInstanceVM(vm, \"" name "\", res, NULL, DefSQDestructorCallback<" name ">); return 1; }" + } else { + print " template <> int Return<" name " *>(HSQUIRRELVM vm, " name " *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, \"" name "\", res, NULL, DefSQDestructorCallback<" name ">); return 1; }" + } +} + +BEGIN { + enum_size = 0 + enum_value_size = 0 + enum_string_to_error_size = 0 + enum_error_to_string_size = 0 + struct_size = 0 + method_size = 0 + static_method_size = 0 + virtual_class = "false" + super_cls = "" + cls = "" + start_squirrel_define_on_next_line = "false" + cls_level = 0 + RS = "\r|\n" +} + +/@file/ { + # Break it in two lines, so SVN doesn't replace it + printf "/* $I" + print "d$ */" + print "/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */" + print "" + print "#include \"" $3 "\"" +} + +# Remove the old squirrel stuff +/#ifdef DEFINE_SQUIRREL_CLASS/ { squirrel_stuff = "true"; next; } +/^#endif \/\* DEFINE_SQUIRREL_CLASS \*\// { if (squirrel_stuff == "true") { squirrel_stuff = "false"; next; } } +{ if (squirrel_stuff == "true") next; } + +# Ignore forward declarations of classes +/^( *)class(.*);/ { next; } +# We only want to have public functions exported for now +/^( *)class/ { + if (cls_level == 0) { + public = "false" + cls_param[0] = "" + cls_param[1] = 1 + cls_param[2] = "x" + cls = $2 + if (match($4, "public") || match($4, "protected") || match($4, "private")) { + super_cls = $5 + } else { + super_cls = $4 + } + } else if (cls_level == 1) { + struct_size++ + structs[struct_size] = cls "::" $2 + } + cls_level++ + next +} +/^( *)public/ { if (cls_level == 1) public = "true"; next; } +/^( *)protected/ { if (cls_level == 1) public = "false"; next; } +/^( *)private/ { if (cls_level == 1) public = "false"; next; } + +# Ignore special doxygen blocks +/^#ifndef DOXYGEN_SKIP/ { doxygen_skip = "next"; next; } +/^#ifdef DOXYGEN_SKIP/ { doxygen_skip = "true"; next; } +/^#endif/ { doxygen_skip = "false"; next; } +/^#else/ { + if (doxygen_skip == "next") { + doxygen_skip = "true"; + } else { + doxygen_skip = "false"; + } + next; +} +{ if (doxygen_skip == "true") next } + +# Ignore the comments +/^#/ { next; } +/\/\*.*\*\// { comment = "false"; next; } +/\/\*/ { comment = "true"; next; } +/\*\// { comment = "false"; next; } +{ if (comment == "true") next } + +# We need to make specialized conversions for structs +/^( *)struct/ { + cls_level++ + if (public == "false") next + if (cls_level != 1) next + struct_size++ + structs[struct_size] = cls "::" $2 + next +} + +# We need to make specialized conversions for enums +/^( *)enum/ { + cls_level++ + if (public == "false") next; + in_enum = "true" + enum_size++ + enums[enum_size] = cls "::" $2 + next +} + +# Maybe the end of the class, if so we can start with the Squirrel export pretty soon +/};/ { + cls_level-- + if (cls_level != 0) { + in_enum = "false"; + next; + } + if (cls == "") { + next; + } + start_squirrel_define_on_next_line = "true" + next; +} + +# Empty/white lines. When we may do the Squirrel export, do that export. +/^([ ]*)$/ { + if (start_squirrel_define_on_next_line == "false") next + spaces = " "; + public = "false" + namespace_opened = "false" + + print "" + + # First check whether we have enums to print + if (enum_size != 0) { + if (namespace_opened == "false") { + print "namespace SQConvert {" + namespace_opened = "true" + } + print " /* Allow enums to be used as Squirrel parameters */" + for (i = 1; i <= enum_size; i++) { + print " template <> " enums[i] " GetParam(ForceType<" enums[i] ">, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (" enums[i] ")tmp; }" + print " template <> int Return<" enums[i] ">(HSQUIRRELVM vm, " enums[i] " res) { sq_pushinteger(vm, (int32)res); return 1; }" + delete enums[i] + } + } + + # Then check whether we have structs/classes to print + if (struct_size != 0) { + if (namespace_opened == "false") { + print "namespace SQConvert {" + namespace_opened = "true" + } + print " /* Allow inner classes/structs to be used as Squirrel parameters */" + for (i = 1; i <= struct_size; i++) { + dump_class_templates(structs[i]) + delete structs[i] + } + } + + if (namespace_opened == "false") { + print "namespace SQConvert {" + namespace_opened = "true" + } else { + print "" + } + print " /* Allow " cls " to be used as Squirrel parameter */" + dump_class_templates(cls) + + print "}; // namespace SQConvert" + + print ""; + # Then do the registration functions of the class. */ + print "void SQ" cls "_Register(Squirrel *engine) {" + print " DefSQClass <" cls "> SQ" cls "(\"" cls "\");" + if (super_cls == "AIObject" || super_cls == "AIAbstractList::Valuator") { + print " SQ" cls ".PreRegister(engine);" + } else { + print " SQ" cls ".PreRegister(engine, \"" super_cls "\");" + } + if (virtual_class == "false" && super_cls != "AIEvent") { + print " SQ" cls ".AddConstructor<void (" cls "::*)(" cls_param[0] "), " cls_param[1]">(engine, \"" cls_param[2] "\");" + } + print "" + + # Enum values + mlen = 0 + for (i = 1; i <= enum_value_size; i++) { + if (mlen <= length(enum_value[i])) mlen = length(enum_value[i]) + } + for (i = 1; i <= enum_value_size; i++) { + print " SQ" cls ".DefSQConst(engine, " cls "::" enum_value[i] ", " substr(spaces, 1, mlen - length(enum_value[i])) "\"" enum_value[i] "\");" + delete enum_value[i] + } + if (enum_value_size != 0) print "" + + # Mapping of OTTD strings to errors + mlen = 0 + for (i = 1; i <= enum_string_to_error_size; i++) { + if (mlen <= length(enum_string_to_error_mapping_string[i])) mlen = length(enum_string_to_error_mapping_string[i]) + } + for (i = 1; i <= enum_string_to_error_size; i++) { + print " AIError::RegisterErrorMap(" enum_string_to_error_mapping_string[i] ", " substr(spaces, 1, mlen - length(enum_string_to_error_mapping_string[i])) cls "::" enum_string_to_error_mapping_error[i] ");" + + delete enum_string_to_error_mapping_string[i] + } + if (enum_string_to_error_size != 0) print "" + + # Mapping of errors to human 'readable' strings. + mlen = 0 + for (i = 1; i <= enum_error_to_string_size; i++) { + if (mlen <= length(enum_error_to_string_mapping[i])) mlen = length(enum_error_to_string_mapping[i]) + } + for (i = 1; i <= enum_error_to_string_size; i++) { + print " AIError::RegisterErrorMapString(" cls "::" enum_error_to_string_mapping[i] ", " substr(spaces, 1, mlen - length(enum_error_to_string_mapping[i])) "\"" enum_error_to_string_mapping[i] "\");" + delete enum_error_to_string_mapping[i] + } + if (enum_error_to_string_size != 0) print "" + + # Static methods + mlen = 0 + for (i = 1; i <= static_method_size; i++) { + if (mlen <= length(static_methods[i, 0])) mlen = length(static_methods[i, 0]) + } + for (i = 1; i <= static_method_size; i++) { + print " SQ" cls ".DefSQStaticMethod(engine, &" cls "::" static_methods[i, 0] ", " substr(spaces, 1, mlen - length(static_methods[i, 0])) "\"" static_methods[i, 0] "\", " substr(spaces, 1, mlen - length(static_methods[i, 0])) "" static_methods[i, 1] ", \"" static_methods[i, 2] "\");" + delete static_methods[i] + } + if (static_method_size != 0) print "" + + if (virtual_class == "false") { + # Non-static methods + mlen = 0 + for (i = 1; i <= method_size; i++) { + if (mlen <= length(methods[i, 0])) mlen = length(methods[i, 0]) + } + for (i = 1; i <= method_size; i++) { + if (methods[i, 2] == "v") { + print " SQ" cls ".DefSQAdvancedMethod(engine, &" cls "::" methods[i, 0] ", " substr(spaces, 1, mlen - length(methods[i, 0]) - 8) "\"" methods[i, 0] "\");" + } else { + print " SQ" cls ".DefSQMethod(engine, &" cls "::" methods[i, 0] ", " substr(spaces, 1, mlen - length(methods[i, 0])) "\"" methods[i, 0] "\", " substr(spaces, 1, mlen - length(methods[i, 0])) "" methods[i, 1] ", \"" methods[i, 2] "\");" + } + delete methods[i] + } + if (method_size != 0) print "" + } + print " SQ" cls ".PostRegister(engine);" + print "}" + + enum_size = 0 + enum_value_size = 0 + enum_string_to_error_size = 0 + enum_error_to_string_size = 0 + struct_size = 0 + method_size = 0 + static_method_size = 0 + virtual_class = "false" + cls = "" + start_squirrel_define_on_next_line = "false" + cls_level = 0 +} + +# Skip non-public functions +{ if (public == "false") next } + +# Add enums +{ + if (in_enum == "true") { + enum_value_size++ + sub(",", "", $1) + enum_value[enum_value_size] = $1 + + # Check if this a special error enum + if (match(enums[enum_size], ".*::ErrorMessages") != 0) { + # syntax: + # enum ErrorMessages { + # ERR_SOME_ERROR, // [STR_ITEM1, STR_ITEM2, ...] + # } + + # Set the mappings + if (match($0, "\\[.*\\]") != 0) { + mappings = substr($0, RSTART, RLENGTH); + gsub("([\\[[:space:]\\]])", "", mappings); + + split(mappings, mapitems, ","); + for (i = 1; i <= length(mapitems); i++) { + enum_string_to_error_size++ + enum_string_to_error_mapping_string[enum_string_to_error_size] = mapitems[i] + enum_string_to_error_mapping_error[enum_string_to_error_size] = $1 + } + + enum_error_to_string_size++ + enum_error_to_string_mapping[enum_error_to_string_size] = $1 + } + } + next + } +} + +# Add a method to the list +/^.*\(.*\).*$/ { + if (cls_level != 1) next + if (match($0, "~")) next + + is_static = match($0, "static") + if (match($0, "virtual")) { + virtual_class = "true" + } + gsub("virtual", "", $0) + gsub("static", "", $0) + gsub("const", "", $0) + gsub("{.*", "", $0) + param_s = $0 + gsub("\\*", "", $0) + gsub("\\(.*", "", $0) + + sub(".*\\(", "", param_s) + sub("\\).*", "", param_s) + + funcname = $2 + if ($1 == cls && funcname == "") { + cls_param[0] = param_s + if (param_s == "") next + } else if (funcname == "") next + + split(param_s, params, ",") + types = "x" + for (len = 1; params[len] != ""; len++) { + sub("^[ ]*", "", params[len]) + if (match(params[len], "\\*") || match(params[len], "&")) { + if (match(params[len], "^char")) { + types = types "s" + } else if (match(params[len], "^void")) { + types = types "p" + } else if (match(params[len], "^Array")) { + types = types "a" + } else if (match(params[len], "^struct Array")) { + types = types "a" + } else { + types = types "x" + } + } else if (match(params[len], "^bool")) { + types = types "b" + } else if (match(params[len], "^HSQUIRRELVM")) { + types = "v" + } else { + types = types "i" + } + } + + if ($1 == cls && funcname == "") { + cls_param[1] = len; + cls_param[2] = types; + } else if (substr(funcname, 0, 1) == "_" && types != "v") { + } else if (is_static) { + static_method_size++ + static_methods[static_method_size, 0] = funcname + static_methods[static_method_size, 1] = len + static_methods[static_method_size, 2] = types + } else { + method_size++ + methods[method_size, 0] = funcname + methods[method_size, 1] = len + methods[method_size, 2] = types + } + next +} diff --git a/src/ai/api/squirrel_export.sh b/src/ai/api/squirrel_export.sh new file mode 100644 index 000000000..ac324390f --- /dev/null +++ b/src/ai/api/squirrel_export.sh @@ -0,0 +1,93 @@ +#!/bin/bash + +# This must be called from within the src/ai/api directory. + +if [ -z "$1" ]; then + for f in `ls *.hpp`; do + case "${f}" in + # these files should not be changed by this script + "ai_controller.hpp" | "ai_object.hpp" | "ai_types.hpp" ) continue; + esac + awk -f squirrel_export.awk ${f} > ${f}.tmp + if ! [ -f "${f}.sq" ] || [ -n "`diff -I '$Id' -b ${f}.tmp ${f}.sq 2> /dev/null || echo boo`" ]; then + mv ${f}.tmp ${f}.sq + echo "Updated: ${f}.sq" + svn add ${f}.sq > /dev/null 2>&1 + svn propset svn:eol-style native ${f}.sq > /dev/null 2>&1 + svn propset svn:keywords Id ${f}.sq > /dev/null 2>&1 + else + rm -f ${f}.tmp + fi + done +else + awk -f squirrel_export.awk $1 > $1.tmp + if ! [ -f "${f}.sq" ] || [ -n "`diff -I '$Id' -b $1.sq $1.tmp 2> /dev/null || echo boo`" ]; then + mv $1.tmp $1.sq + echo "Updated: $1.sq" + svn add $1.sq > /dev/null 2>&1 + svn propset svn:eol-style native $1.sq > /dev/null 2>&1 + svn propset svn:keywords Id $1.sq > /dev/null 2>&1 + else + rm -f $1.tmp + fi +fi + +# Remove .hpp.sq if .hpp doesn't exist anymore +for f in `ls *.hpp.sq`; do + f=`echo ${f} | sed "s/.hpp.sq$/.hpp/"` + if [ ! -f ${f} ];then + echo "Deleted: ${f}.sq" + svn del --force ${f}.sq > /dev/null 2>&1 + fi +done + +# Add stuff to ai_instance.cpp +f='../ai_instance.cpp' + +functions=`` + +echo " +{ } +/.hpp.sq/ { next } +/squirrel_register_std/ { next } +/SQAIController_Register/ { print \$0; next } +/SQAI.*_Register/ { next } + +/Note: this line a marker in squirrel_export.sh. Do not change!/ { + print \$0 + gsub(\"^.*/\", \"\") + split(\"`grep '^void SQAI.*_Register(Squirrel \*engine) {$' *.hpp.sq | sed 's/:.*$//' | sort | uniq | tr -d '\r' | tr '\n' ' '`\", files, \" \") + + for (i = 1; files[i] != \"\"; i++) { + print \"#include \\\"api/\" files[i] \"\\\"\" \$0 + } + + next; +} + +/\/\* Register all classes \*\// { + print \$0 + gsub(\"^.*/\", \"\") + print \" squirrel_register_std(this->engine);\" \$0 + split(\"`grep '^void SQAI.*_Register(Squirrel \*engine) {$' *.hpp.sq | sed 's/^.*void //;s/Squirrel \*/this->/;s/ {/;/;s/_Register/0000Register/g;' | sort | sed 's/0000Register/_Register/g' | tr -d '\r' | tr '\n' ' '`\", regs, \" \") + + for (i = 1; regs[i] != \"\"; i++) { + if (regs[i] == \"SQAIController_Register(this->engine);\") continue + print \" \" regs[i] \$0 + } + + next +} + +{ print \$0; } +" > ${f}.awk + +awk -f ${f}.awk ${f} > ${f}.tmp + +if ! [ -f "${f}" ] || [ -n "`diff -I '$Id' -b ${f} ${f}.tmp 2> /dev/null || echo boo`" ]; then + mv ${f}.tmp ${f} + echo "Updated: ${f}" +else + rm -f ${f}.tmp +fi +rm -f ${f}.awk diff --git a/src/ai/default/default.cpp b/src/ai/default/default.cpp deleted file mode 100644 index 74d9b7ac5..000000000 --- a/src/ai/default/default.cpp +++ /dev/null @@ -1,4028 +0,0 @@ -/* $Id$ */ - -/** @file default.cpp The original AI. */ - -#include "../../stdafx.h" -#include "../../openttd.h" -#include "../../aircraft.h" -#include "../../bridge_map.h" -#include "../../tile_cmd.h" -#include "../../landscape.h" -#include "../../rail_map.h" -#include "../../road_map.h" -#include "../../roadveh.h" -#include "../../station_map.h" -#include "../../tunnel_map.h" -#include "../../command_func.h" -#include "../../town.h" -#include "../../industry.h" -#include "../../pathfind.h" -#include "../../airport.h" -#include "../../variables.h" -#include "../../bridge.h" -#include "../../date_func.h" -#include "../../tunnelbridge_map.h" -#include "../../window_func.h" -#include "../../vehicle_func.h" -#include "../../functions.h" -#include "../../company_func.h" -#include "../../company_base.h" -#include "../../settings_type.h" -#include "default.h" -#include "../../tunnelbridge.h" -#include "../../order_func.h" - -#include "../../table/ai_rail.h" - -// remove some day perhaps? -static uint _ai_service_interval; -CompanyAI _companies_ai[MAX_COMPANIES]; - -typedef void AiStateAction(Company *c); - -enum { - AIS_0 = 0, - AIS_1 = 1, - AIS_VEH_LOOP = 2, - AIS_VEH_CHECK_REPLACE_VEHICLE = 3, - AIS_VEH_DO_REPLACE_VEHICLE = 4, - AIS_WANT_NEW_ROUTE = 5, - AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6, - AIS_BUILD_RAIL = 7, - AIS_BUILD_RAIL_VEH = 8, - AIS_DELETE_RAIL_BLOCKS = 9, - AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10, - AIS_BUILD_ROAD = 11, - AIS_BUILD_ROAD_VEHICLES = 12, - AIS_DELETE_ROAD_BLOCKS = 13, - AIS_AIRPORT_STUFF = 14, - AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15, - AIS_BUILD_AIRCRAFT_VEHICLES = 16, - AIS_CHECK_SHIP_STUFF = 17, - AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18, - AIS_DO_SHIP_STUFF = 19, - AIS_SELL_VEHICLE = 20, - AIS_REMOVE_STATION = 21, - AIS_REMOVE_TRACK = 22, - AIS_REMOVE_SINGLE_RAIL_TILE = 23 -}; - - -static inline TrackBits GetRailTrackStatus(TileIndex tile) -{ - return TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)); -} - - -static void AiCase0(Company *c) -{ - _companies_ai[c->index].state = AIS_REMOVE_TRACK; - _companies_ai[c->index].state_counter = 0; -} - -static void AiCase1(Company *c) -{ - _companies_ai[c->index].cur_veh = NULL; - _companies_ai[c->index].state = AIS_VEH_LOOP; -} - -static void AiStateVehLoop(Company *c) -{ - Vehicle *v; - uint index; - - index = (_companies_ai[c->index].cur_veh == NULL) ? 0 : _companies_ai[c->index].cur_veh->index + 1; - - FOR_ALL_VEHICLES_FROM(v, index) { - if (v->owner != _current_company) continue; - - if ((v->type == VEH_TRAIN && v->subtype == 0) || - v->type == VEH_ROAD || - (v->type == VEH_AIRCRAFT && IsNormalAircraft(v)) || - v->type == VEH_SHIP) { - /* replace engine? */ - if (v->type == VEH_TRAIN && v->engine_type < 3 && - (_price.build_railvehicle >> 3) < c->money) { - _companies_ai[c->index].state = AIS_VEH_CHECK_REPLACE_VEHICLE; - _companies_ai[c->index].cur_veh = v; - return; - } - - /* not profitable? */ - if (v->age >= 730 && - v->profit_last_year < _price.station_value * 5 * 256 && - v->profit_this_year < _price.station_value * 5 * 256) { - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].state = AIS_SELL_VEHICLE; - _companies_ai[c->index].cur_veh = v; - return; - } - - /* not reliable? */ - if (v->age >= v->max_age || ( - v->age != 0 && - GetEngine(v->engine_type)->reliability < 35389 - )) { - _companies_ai[c->index].state = AIS_VEH_CHECK_REPLACE_VEHICLE; - _companies_ai[c->index].cur_veh = v; - return; - } - } - } - - _companies_ai[c->index].state = AIS_WANT_NEW_ROUTE; - _companies_ai[c->index].state_counter = 0; -} - -static EngineID AiChooseTrainToBuild(RailType railtype, Money money, byte flag, TileIndex tile) -{ - EngineID best_veh_index = INVALID_ENGINE; - byte best_veh_score = 0; - const Engine *e; - - FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) { - EngineID i = e->index; - const RailVehicleInfo *rvi = &e->u.rail; - - if (!IsCompatibleRail(rvi->railtype, railtype) || - rvi->railveh_type == RAILVEH_WAGON || - (rvi->railveh_type == RAILVEH_MULTIHEAD && flag & 1) || - !HasBit(e->company_avail, _current_company) || - e->reliability < 0x8A3D) { - continue; - } - - /* Don't choose an engine designated for passenger use for freight. */ - if (rvi->ai_passenger_only != 0 && flag == 1) continue; - - CommandCost ret = DoCommand(tile, i, 0, 0, CMD_BUILD_RAIL_VEHICLE); - if (CmdSucceeded(ret) && ret.GetCost() <= money && rvi->ai_rank >= best_veh_score) { - best_veh_score = rvi->ai_rank; - best_veh_index = i; - } - } - - return best_veh_index; -} - -static EngineID AiChooseRoadVehToBuild(CargoID cargo, Money money, TileIndex tile) -{ - EngineID best_veh_index = INVALID_ENGINE; - int32 best_veh_rating = 0; - const Engine *e; - - FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) { - EngineID i = e->index; - const RoadVehicleInfo *rvi = &e->u.road; - - if (!HasBit(e->company_avail, _current_company) || e->reliability < 0x8A3D) { - continue; - } - - /* Skip vehicles which can't take our cargo type */ - if (rvi->cargo_type != cargo && !CanRefitTo(i, cargo)) continue; - - /* Rate and compare the engine by speed & capacity */ - int rating = rvi->max_speed * rvi->capacity; - if (rating <= best_veh_rating) continue; - - CommandCost ret = DoCommand(tile, i, 0, 0, CMD_BUILD_ROAD_VEH); - if (CmdFailed(ret)) continue; - - /* Add the cost of refitting */ - if (rvi->cargo_type != cargo) ret.AddCost(GetRefitCost(i)); - if (ret.GetCost() > money) continue; - - best_veh_rating = rating; - best_veh_index = i; - } - - return best_veh_index; -} - -/** - * Choose aircraft to build. - * @param money current AI money - * @param forbidden forbidden flags - AIR_HELI = 0 (always allowed), AIR_CTOL = 1 (bit 0), AIR_FAST = 2 (bit 1) - * @return EngineID of aircraft to build - */ -static EngineID AiChooseAircraftToBuild(Money money, byte forbidden) -{ - EngineID best_veh_index = INVALID_ENGINE; - Money best_veh_cost = 0; - const Engine *e; - - FOR_ALL_ENGINES_OF_TYPE(e, VEH_AIRCRAFT) { - EngineID i = e->index; - const AircraftVehicleInfo *avi = &e->u.air; - - if (!HasBit(e->company_avail, _current_company) || e->reliability < 0x8A3D) { - continue; - } - - if ((avi->subtype & forbidden) != 0) continue; - - CommandCost ret = DoCommand(0, i, 0, DC_QUERY_COST, CMD_BUILD_AIRCRAFT); - if (CmdSucceeded(ret) && ret.GetCost() <= money && ret.GetCost() >= best_veh_cost) { - best_veh_cost = ret.GetCost(); - best_veh_index = i; - } - } - - return best_veh_index; -} - -static Money AiGetBasePrice(const Company *c) -{ - Money base = _price.station_value; - - // adjust base price when more expensive vehicles are available - switch (_companies_ai[c->index].railtype_to_use) { - default: NOT_REACHED(); - case RAILTYPE_RAIL: break; - case RAILTYPE_ELECTRIC: break; - case RAILTYPE_MONO: base = (base * 3) >> 1; break; - case RAILTYPE_MAGLEV: base *= 2; break; - } - - return base; -} - -static EngineID AiChooseRoadVehToReplaceWith(const Company *c, const Vehicle *v) -{ - Money avail_money = c->money + v->value; - return AiChooseRoadVehToBuild(v->cargo_type, avail_money, v->tile); -} - -static EngineID AiChooseAircraftToReplaceWith(const Company *c, const Vehicle *v) -{ - Money avail_money = c->money + v->value; - - /* determine forbidden aircraft bits */ - byte forbidden = 0; - const Order *o; - - FOR_VEHICLE_ORDERS(v, o) { - if (!o->IsValid()) continue; - if (!IsValidStationID(o->GetDestination())) continue; - const Station *st = GetStation(o->GetDestination()); - if (!(st->facilities & FACIL_AIRPORT)) continue; - - AirportFTAClass::Flags flags = st->Airport()->flags; - if (!(flags & AirportFTAClass::AIRPLANES)) forbidden |= AIR_CTOL | AIR_FAST; // no planes for heliports / oil rigs - if (flags & AirportFTAClass::SHORT_STRIP) forbidden |= AIR_FAST; // no fast planes for small airports - } - - return AiChooseAircraftToBuild( - avail_money, forbidden - ); -} - -static EngineID AiChooseTrainToReplaceWith(const Company *c, const Vehicle *v) -{ - Money avail_money = c->money + v->value; - const Vehicle *u = v; - int num = 0; - - while (++num, u->Next() != NULL) { - u = u->Next(); - } - - // XXX: check if a wagon - return AiChooseTrainToBuild(v->u.rail.railtype, avail_money, 0, v->tile); -} - -static EngineID AiChooseShipToReplaceWith(const Company *c, const Vehicle *v) -{ - /* Ships are not implemented in this (broken) AI */ - return INVALID_ENGINE; -} - -static void AiHandleGotoDepot(Company *c, int cmd) -{ - if (!_companies_ai[c->index].cur_veh->current_order.IsType(OT_GOTO_DEPOT)) - DoCommand(0, _companies_ai[c->index].cur_veh->index, 0, DC_EXEC, cmd); - - if (++_companies_ai[c->index].state_counter <= 1387) { - _companies_ai[c->index].state = AIS_VEH_DO_REPLACE_VEHICLE; - return; - } - - if (_companies_ai[c->index].cur_veh->current_order.IsType(OT_GOTO_DEPOT)) { - _companies_ai[c->index].cur_veh->current_order.MakeDummy(); - InvalidateWindow(WC_VEHICLE_VIEW, _companies_ai[c->index].cur_veh->index); - } -} - -static void AiRestoreVehicleOrders(Vehicle *v, BackuppedOrders *bak) -{ - if (bak->order == NULL) return; - - for (uint i = 0; !bak->order[i].IsType(OT_NOTHING); i++) { - if (!DoCommandP(0, v->index + (i << 16), bak->order[i].Pack(), CMD_INSERT_ORDER | CMD_NO_TEST_IF_IN_NETWORK)) - break; - } -} - -static void AiHandleReplaceTrain(Company *c) -{ - const Vehicle *v = _companies_ai[c->index].cur_veh; - BackuppedOrders orderbak; - EngineID veh; - - // wait until the vehicle reaches the depot. - if (!IsRailDepotTile(v->tile) || v->u.rail.track != TRACK_BIT_DEPOT || !(v->vehstatus & VS_STOPPED)) { - AiHandleGotoDepot(c, CMD_SEND_TRAIN_TO_DEPOT); - return; - } - - veh = AiChooseTrainToReplaceWith(c, v); - if (veh != INVALID_ENGINE) { - TileIndex tile; - - BackupVehicleOrders(v, &orderbak); - tile = v->tile; - - if (CmdSucceeded(DoCommand(0, v->index, 2, DC_EXEC, CMD_SELL_RAIL_WAGON)) && - CmdSucceeded(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE))) { - VehicleID veh = _new_vehicle_id; - AiRestoreVehicleOrders(GetVehicle(veh), &orderbak); - DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_VEHICLE); - - DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT); - } - } -} - -static void AiHandleReplaceRoadVeh(Company *c) -{ - const Vehicle *v = _companies_ai[c->index].cur_veh; - BackuppedOrders orderbak; - EngineID veh; - - if (!v->IsStoppedInDepot()) { - AiHandleGotoDepot(c, CMD_SEND_ROADVEH_TO_DEPOT); - return; - } - - veh = AiChooseRoadVehToReplaceWith(c, v); - if (veh != INVALID_ENGINE) { - TileIndex tile; - - BackupVehicleOrders(v, &orderbak); - tile = v->tile; - - if (CmdSucceeded(DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH)) && - CmdSucceeded(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH))) { - VehicleID veh = _new_vehicle_id; - - AiRestoreVehicleOrders(GetVehicle(veh), &orderbak); - DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_VEHICLE); - DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT); - } - } -} - -static void AiHandleReplaceAircraft(Company *c) -{ - const Vehicle *v = _companies_ai[c->index].cur_veh; - BackuppedOrders orderbak; - EngineID veh; - - if (!v->IsStoppedInDepot()) { - AiHandleGotoDepot(c, CMD_SEND_AIRCRAFT_TO_HANGAR); - return; - } - - veh = AiChooseAircraftToReplaceWith(c, v); - if (veh != INVALID_ENGINE) { - TileIndex tile; - - BackupVehicleOrders(v, &orderbak); - tile = v->tile; - - if (CmdSucceeded(DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT)) && - CmdSucceeded(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT))) { - VehicleID veh = _new_vehicle_id; - AiRestoreVehicleOrders(GetVehicle(veh), &orderbak); - DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_VEHICLE); - - DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT); - } - } -} - -static void AiHandleReplaceShip(Company *c) -{ - /* Ships are not implemented in this (broken) AI */ -} - -typedef EngineID CheckReplaceProc(const Company *c, const Vehicle *v); - -static CheckReplaceProc * const _veh_check_replace_proc[] = { - AiChooseTrainToReplaceWith, - AiChooseRoadVehToReplaceWith, - AiChooseShipToReplaceWith, - AiChooseAircraftToReplaceWith, -}; - -typedef void DoReplaceProc(Company *c); -static DoReplaceProc * const _veh_do_replace_proc[] = { - AiHandleReplaceTrain, - AiHandleReplaceRoadVeh, - AiHandleReplaceShip, - AiHandleReplaceAircraft -}; - -static void AiStateCheckReplaceVehicle(Company *c) -{ - const Vehicle *v = _companies_ai[c->index].cur_veh; - - if (!v->IsValid() || - v->owner != _current_company || - v->type > VEH_SHIP || - _veh_check_replace_proc[v->type - VEH_TRAIN](c, v) == INVALID_ENGINE) { - _companies_ai[c->index].state = AIS_VEH_LOOP; - } else { - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].state = AIS_VEH_DO_REPLACE_VEHICLE; - } -} - -static void AiStateDoReplaceVehicle(Company *c) -{ - const Vehicle *v = _companies_ai[c->index].cur_veh; - - _companies_ai[c->index].state = AIS_VEH_LOOP; - // vehicle is not owned by the company anymore, something went very wrong. - if (!v->IsValid() || v->owner != _current_company) return; - _veh_do_replace_proc[v->type - VEH_TRAIN](c); -} - -struct FoundRoute { - int distance; - CargoID cargo; - void *from; - void *to; -}; - -static Town *AiFindRandomTown() -{ - return GetRandomTown(); -} - -static Industry *AiFindRandomIndustry() -{ - int num = RandomRange(GetMaxIndustryIndex()); - if (IsValidIndustryID(num)) return GetIndustry(num); - - return NULL; -} - -static void AiFindSubsidyIndustryRoute(FoundRoute *fr) -{ - uint i; - CargoID cargo; - const Subsidy *s; - Industry *from; - TileIndex to_xy; - - // initially error - fr->distance = -1; - - // Randomize subsidy index.. - i = RandomRange(lengthof(_subsidies) * 3); - if (i >= lengthof(_subsidies)) return; - - s = &_subsidies[i]; - - // Don't want passengers or mail - cargo = s->cargo_type; - if (cargo == CT_INVALID || - cargo == CT_PASSENGERS || - cargo == CT_MAIL || - s->age > 7) { - return; - } - fr->cargo = cargo; - - fr->from = from = GetIndustry(s->from); - - if (cargo == CT_GOODS || cargo == CT_FOOD) { - Town *to_tow = GetTown(s->to); - - if (to_tow->population < (cargo == CT_FOOD ? 200U : 900U)) return; // error - fr->to = to_tow; - to_xy = to_tow->xy; - } else { - Industry *to_ind = GetIndustry(s->to); - - fr->to = to_ind; - to_xy = to_ind->xy; - } - - fr->distance = DistanceManhattan(from->xy, to_xy); -} - -static void AiFindSubsidyPassengerRoute(FoundRoute *fr) -{ - uint i; - const Subsidy *s; - Town *from, *to; - - // initially error - fr->distance = -1; - - // Randomize subsidy index.. - i = RandomRange(lengthof(_subsidies) * 3); - if (i >= lengthof(_subsidies)) return; - - s = &_subsidies[i]; - - // Only want passengers - if (s->cargo_type != CT_PASSENGERS || s->age > 7) return; - fr->cargo = s->cargo_type; - - fr->from = from = GetTown(s->from); - fr->to = to = GetTown(s->to); - - // They must be big enough - if (from->population < 400 || to->population < 400) return; - - fr->distance = DistanceManhattan(from->xy, to->xy); -} - -static void AiFindRandomIndustryRoute(FoundRoute *fr) -{ - Industry *i; - uint32 r; - CargoID cargo; - - // initially error - fr->distance = -1; - - r = Random(); - - // pick a source - fr->from = i = AiFindRandomIndustry(); - if (i == NULL) return; - - // pick a random produced cargo - cargo = i->produced_cargo[0]; - if (r & 1 && i->produced_cargo[1] != CT_INVALID) cargo = i->produced_cargo[1]; - - fr->cargo = cargo; - - // don't allow passengers - if (cargo == CT_INVALID || cargo == CT_PASSENGERS) return; - - if (cargo != CT_GOODS && cargo != CT_FOOD) { - // pick a dest, and see if it can receive - Industry *i2 = AiFindRandomIndustry(); - if (i2 == NULL || i == i2 || - (i2->accepts_cargo[0] != cargo && - i2->accepts_cargo[1] != cargo && - i2->accepts_cargo[2] != cargo)) { - return; - } - - fr->to = i2; - fr->distance = DistanceManhattan(i->xy, i2->xy); - } else { - // pick a dest town, and see if it's big enough - Town *t = AiFindRandomTown(); - - if (t == NULL || t->population < (cargo == CT_FOOD ? 200U : 900U)) return; - - fr->to = t; - fr->distance = DistanceManhattan(i->xy, t->xy); - } -} - -static void AiFindRandomPassengerRoute(FoundRoute *fr) -{ - Town *source; - Town *dest; - - // initially error - fr->distance = -1; - - fr->from = source = AiFindRandomTown(); - if (source == NULL || source->population < 400) return; - - fr->to = dest = AiFindRandomTown(); - if (dest == NULL || source == dest || dest->population < 400) return; - - fr->distance = DistanceManhattan(source->xy, dest->xy); -} - -// Warn: depends on 'xy' being the first element in both Town and Industry -#define GET_TOWN_OR_INDUSTRY_TILE(p) (((Town*)(p))->xy) - -static bool AiCheckIfRouteIsGood(Company *c, FoundRoute *fr, byte bitmask) -{ - TileIndex from_tile, to_tile; - Station *st; - int dist; - uint same_station = 0; - - from_tile = GET_TOWN_OR_INDUSTRY_TILE(fr->from); - to_tile = GET_TOWN_OR_INDUSTRY_TILE(fr->to); - - dist = 0xFFFF; - FOR_ALL_STATIONS(st) { - int cur; - - if (st->owner != _current_company) continue; - cur = DistanceMax(from_tile, st->xy); - if (cur < dist) dist = cur; - cur = DistanceMax(to_tile, st->xy); - if (cur < dist) dist = cur; - if (to_tile == from_tile && st->xy == to_tile) same_station++; - } - - // To prevent the AI from building ten busstations in the same town, do some calculations - // For each road or airport station, we want 350 of population! - if ((bitmask == 2 || bitmask == 4) && - same_station > 2 && - ((Town*)fr->from)->population < same_station * 350) { - return false; - } - - /* Requiring distance to nearest station to be always under 37 tiles may be suboptimal, - * Especially for longer aircraft routes that start and end pretty at any arbitrary place on map - * While it may be nice for AI to cluster their creations together, hardcoded limit is not ideal. - * If AI will randomly start on some isolated spot, it will never get out of there. - * AI will have chance of randomly rejecting routes further than 37 tiles from their network, - * so there will be some attempt to cluster the network together */ - - /* Random value between 37 and 292. Low values are exponentially more likely - * With 50% chance the value will be under 52 tiles */ - int min_distance = 36 + (1 << (Random() % 9)); // 0..8 - - /* Make sure distance to closest station is < min_distance tiles. */ - if (dist != 0xFFFF && dist > min_distance) return false; - - if (_companies_ai[c->index].route_type_mask != 0 && - !(_companies_ai[c->index].route_type_mask & bitmask) && - !Chance16(1, 5)) { - return false; - } - - if (fr->cargo == CT_PASSENGERS || fr->cargo == CT_MAIL) { - const Town *from = (const Town*)fr->from; - const Town *to = (const Town*)fr->to; - - if (from->pct_pass_transported > 0x99 || - to->pct_pass_transported > 0x99) { - return false; - } - - // Make sure it has a reasonably good rating - if (from->ratings[_current_company] < -100 || - to->ratings[_current_company] < -100) { - return false; - } - } else { - const Industry *i = (const Industry*)fr->from; - - if (i->last_month_pct_transported[fr->cargo != i->produced_cargo[0]] > 0x99 || - i->last_month_production[fr->cargo != i->produced_cargo[0]] == 0) { - return false; - } - } - - _companies_ai[c->index].route_type_mask |= bitmask; - return true; -} - -static byte AiGetDirectionBetweenTiles(TileIndex a, TileIndex b) -{ - byte i = (TileX(a) < TileX(b)) ? 1 : 0; - if (TileY(a) >= TileY(b)) i ^= 3; - return i; -} - -static TileIndex AiGetPctTileBetween(TileIndex a, TileIndex b, byte pct) -{ - return TileXY( - TileX(a) + ((TileX(b) - TileX(a)) * pct >> 8), - TileY(a) + ((TileY(b) - TileY(a)) * pct >> 8) - ); -} - -static void AiWantLongIndustryRoute(Company *c) -{ - int i; - FoundRoute fr; - - i = 60; - for (;;) { - // look for one from the subsidy list - AiFindSubsidyIndustryRoute(&fr); - if (IsInsideMM(fr.distance, 60, 90 + 1)) break; - - // try a random one - AiFindRandomIndustryRoute(&fr); - if (IsInsideMM(fr.distance, 60, 90 + 1)) break; - - // only test 60 times - if (--i == 0) return; - } - - if (!AiCheckIfRouteIsGood(c, &fr, 1)) return; - - // Fill the source field - _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to); - _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from); - - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 9; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.unk6 = 1; - _companies_ai[c->index].src.unk7 = 0; - _companies_ai[c->index].src.buildcmd_a = 0x24; - _companies_ai[c->index].src.buildcmd_b = 0xFF; - _companies_ai[c->index].src.direction = AiGetDirectionBetweenTiles( - _companies_ai[c->index].src.spec_tile, - _companies_ai[c->index].dst.spec_tile - ); - _companies_ai[c->index].src.cargo = fr.cargo | 0x80; - - // Fill the dest field - - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 9; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.unk6 = 1; - _companies_ai[c->index].dst.unk7 = 0; - _companies_ai[c->index].dst.buildcmd_a = 0x34; - _companies_ai[c->index].dst.buildcmd_b = 0xFF; - _companies_ai[c->index].dst.direction = AiGetDirectionBetweenTiles( - _companies_ai[c->index].dst.spec_tile, - _companies_ai[c->index].src.spec_tile - ); - _companies_ai[c->index].dst.cargo = fr.cargo; - - // Fill middle field 1 - _companies_ai[c->index].mid1.spec_tile = AiGetPctTileBetween( - _companies_ai[c->index].src.spec_tile, - _companies_ai[c->index].dst.spec_tile, - 0x55 - ); - _companies_ai[c->index].mid1.use_tile = 0; - _companies_ai[c->index].mid1.rand_rng = 6; - _companies_ai[c->index].mid1.cur_building_rule = 0xFF; - _companies_ai[c->index].mid1.unk6 = 2; - _companies_ai[c->index].mid1.unk7 = 1; - _companies_ai[c->index].mid1.buildcmd_a = 0x30; - _companies_ai[c->index].mid1.buildcmd_b = 0xFF; - _companies_ai[c->index].mid1.direction = _companies_ai[c->index].src.direction; - _companies_ai[c->index].mid1.cargo = fr.cargo; - - // Fill middle field 2 - _companies_ai[c->index].mid2.spec_tile = AiGetPctTileBetween( - _companies_ai[c->index].src.spec_tile, - _companies_ai[c->index].dst.spec_tile, - 0xAA - ); - _companies_ai[c->index].mid2.use_tile = 0; - _companies_ai[c->index].mid2.rand_rng = 6; - _companies_ai[c->index].mid2.cur_building_rule = 0xFF; - _companies_ai[c->index].mid2.unk6 = 2; - _companies_ai[c->index].mid2.unk7 = 1; - _companies_ai[c->index].mid2.buildcmd_a = 0xFF; - _companies_ai[c->index].mid2.buildcmd_b = 0xFF; - _companies_ai[c->index].mid2.direction = _companies_ai[c->index].dst.direction; - _companies_ai[c->index].mid2.cargo = fr.cargo; - - // Fill common fields - _companies_ai[c->index].cargo_type = fr.cargo; - _companies_ai[c->index].num_wagons = 3; - _companies_ai[c->index].build_kind = 2; - _companies_ai[c->index].num_build_rec = 4; - _companies_ai[c->index].num_loco_to_build = 2; - _companies_ai[c->index].num_want_fullload = 2; - _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - - _companies_ai[c->index].state = AIS_BUILD_DEFAULT_RAIL_BLOCKS; - _companies_ai[c->index].state_mode = UCHAR_MAX; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantMediumIndustryRoute(Company *c) -{ - int i; - FoundRoute fr; - - i = 60; - for (;;) { - // look for one from the subsidy list - AiFindSubsidyIndustryRoute(&fr); - if (IsInsideMM(fr.distance, 40, 60 + 1)) break; - - // try a random one - AiFindRandomIndustryRoute(&fr); - if (IsInsideMM(fr.distance, 40, 60 + 1)) break; - - // only test 60 times - if (--i == 0) return; - } - - if (!AiCheckIfRouteIsGood(c, &fr, 1)) return; - - // Fill the source field - _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from); - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 9; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.unk6 = 1; - _companies_ai[c->index].src.unk7 = 0; - _companies_ai[c->index].src.buildcmd_a = 0x10; - _companies_ai[c->index].src.buildcmd_b = 0xFF; - _companies_ai[c->index].src.direction = AiGetDirectionBetweenTiles( - GET_TOWN_OR_INDUSTRY_TILE(fr.from), - GET_TOWN_OR_INDUSTRY_TILE(fr.to) - ); - _companies_ai[c->index].src.cargo = fr.cargo | 0x80; - - // Fill the dest field - _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to); - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 9; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.unk6 = 1; - _companies_ai[c->index].dst.unk7 = 0; - _companies_ai[c->index].dst.buildcmd_a = 0xFF; - _companies_ai[c->index].dst.buildcmd_b = 0xFF; - _companies_ai[c->index].dst.direction = AiGetDirectionBetweenTiles( - GET_TOWN_OR_INDUSTRY_TILE(fr.to), - GET_TOWN_OR_INDUSTRY_TILE(fr.from) - ); - _companies_ai[c->index].dst.cargo = fr.cargo; - - // Fill common fields - _companies_ai[c->index].cargo_type = fr.cargo; - _companies_ai[c->index].num_wagons = 3; - _companies_ai[c->index].build_kind = 1; - _companies_ai[c->index].num_build_rec = 2; - _companies_ai[c->index].num_loco_to_build = 1; - _companies_ai[c->index].num_want_fullload = 1; - _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - _companies_ai[c->index].state = AIS_BUILD_DEFAULT_RAIL_BLOCKS; - _companies_ai[c->index].state_mode = UCHAR_MAX; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantShortIndustryRoute(Company *c) -{ - int i; - FoundRoute fr; - - i = 60; - for (;;) { - // look for one from the subsidy list - AiFindSubsidyIndustryRoute(&fr); - if (IsInsideMM(fr.distance, 15, 40 + 1)) break; - - // try a random one - AiFindRandomIndustryRoute(&fr); - if (IsInsideMM(fr.distance, 15, 40 + 1)) break; - - // only test 60 times - if (--i == 0) return; - } - - if (!AiCheckIfRouteIsGood(c, &fr, 1)) return; - - // Fill the source field - _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from); - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 9; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.unk6 = 1; - _companies_ai[c->index].src.unk7 = 0; - _companies_ai[c->index].src.buildcmd_a = 0x10; - _companies_ai[c->index].src.buildcmd_b = 0xFF; - _companies_ai[c->index].src.direction = AiGetDirectionBetweenTiles( - GET_TOWN_OR_INDUSTRY_TILE(fr.from), - GET_TOWN_OR_INDUSTRY_TILE(fr.to) - ); - _companies_ai[c->index].src.cargo = fr.cargo | 0x80; - - // Fill the dest field - _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to); - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 9; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.unk6 = 1; - _companies_ai[c->index].dst.unk7 = 0; - _companies_ai[c->index].dst.buildcmd_a = 0xFF; - _companies_ai[c->index].dst.buildcmd_b = 0xFF; - _companies_ai[c->index].dst.direction = AiGetDirectionBetweenTiles( - GET_TOWN_OR_INDUSTRY_TILE(fr.to), - GET_TOWN_OR_INDUSTRY_TILE(fr.from) - ); - _companies_ai[c->index].dst.cargo = fr.cargo; - - // Fill common fields - _companies_ai[c->index].cargo_type = fr.cargo; - _companies_ai[c->index].num_wagons = 2; - _companies_ai[c->index].build_kind = 1; - _companies_ai[c->index].num_build_rec = 2; - _companies_ai[c->index].num_loco_to_build = 1; - _companies_ai[c->index].num_want_fullload = 1; - _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - _companies_ai[c->index].state = AIS_BUILD_DEFAULT_RAIL_BLOCKS; - _companies_ai[c->index].state_mode = UCHAR_MAX; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantMailRoute(Company *c) -{ - int i; - FoundRoute fr; - - i = 60; - for (;;) { - // look for one from the subsidy list - AiFindSubsidyPassengerRoute(&fr); - if (IsInsideMM(fr.distance, 60, 110 + 1)) break; - - // try a random one - AiFindRandomPassengerRoute(&fr); - if (IsInsideMM(fr.distance, 60, 110 + 1)) break; - - // only test 60 times - if (--i == 0) return; - } - - fr.cargo = CT_MAIL; - if (!AiCheckIfRouteIsGood(c, &fr, 1)) return; - - // Fill the source field - _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from); - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 7; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.unk6 = 1; - _companies_ai[c->index].src.unk7 = 0; - _companies_ai[c->index].src.buildcmd_a = 0x24; - _companies_ai[c->index].src.buildcmd_b = 0xFF; - _companies_ai[c->index].src.direction = AiGetDirectionBetweenTiles( - GET_TOWN_OR_INDUSTRY_TILE(fr.from), - GET_TOWN_OR_INDUSTRY_TILE(fr.to) - ); - _companies_ai[c->index].src.cargo = fr.cargo; - - // Fill the dest field - _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to); - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 7; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.unk6 = 1; - _companies_ai[c->index].dst.unk7 = 0; - _companies_ai[c->index].dst.buildcmd_a = 0x34; - _companies_ai[c->index].dst.buildcmd_b = 0xFF; - _companies_ai[c->index].dst.direction = AiGetDirectionBetweenTiles( - GET_TOWN_OR_INDUSTRY_TILE(fr.to), - GET_TOWN_OR_INDUSTRY_TILE(fr.from) - ); - _companies_ai[c->index].dst.cargo = fr.cargo; - - // Fill middle field 1 - _companies_ai[c->index].mid1.spec_tile = AiGetPctTileBetween( - GET_TOWN_OR_INDUSTRY_TILE(fr.from), - GET_TOWN_OR_INDUSTRY_TILE(fr.to), - 0x55 - ); - _companies_ai[c->index].mid1.use_tile = 0; - _companies_ai[c->index].mid1.rand_rng = 6; - _companies_ai[c->index].mid1.cur_building_rule = 0xFF; - _companies_ai[c->index].mid1.unk6 = 2; - _companies_ai[c->index].mid1.unk7 = 1; - _companies_ai[c->index].mid1.buildcmd_a = 0x30; - _companies_ai[c->index].mid1.buildcmd_b = 0xFF; - _companies_ai[c->index].mid1.direction = _companies_ai[c->index].src.direction; - _companies_ai[c->index].mid1.cargo = fr.cargo; - - // Fill middle field 2 - _companies_ai[c->index].mid2.spec_tile = AiGetPctTileBetween( - GET_TOWN_OR_INDUSTRY_TILE(fr.from), - GET_TOWN_OR_INDUSTRY_TILE(fr.to), - 0xAA - ); - _companies_ai[c->index].mid2.use_tile = 0; - _companies_ai[c->index].mid2.rand_rng = 6; - _companies_ai[c->index].mid2.cur_building_rule = 0xFF; - _companies_ai[c->index].mid2.unk6 = 2; - _companies_ai[c->index].mid2.unk7 = 1; - _companies_ai[c->index].mid2.buildcmd_a = 0xFF; - _companies_ai[c->index].mid2.buildcmd_b = 0xFF; - _companies_ai[c->index].mid2.direction = _companies_ai[c->index].dst.direction; - _companies_ai[c->index].mid2.cargo = fr.cargo; - - // Fill common fields - _companies_ai[c->index].cargo_type = fr.cargo; - _companies_ai[c->index].num_wagons = 3; - _companies_ai[c->index].build_kind = 2; - _companies_ai[c->index].num_build_rec = 4; - _companies_ai[c->index].num_loco_to_build = 2; - _companies_ai[c->index].num_want_fullload = 0; - _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - _companies_ai[c->index].state = AIS_BUILD_DEFAULT_RAIL_BLOCKS; - _companies_ai[c->index].state_mode = UCHAR_MAX; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantPassengerRoute(Company *c) -{ - int i; - FoundRoute fr; - - i = 60; - for (;;) { - // look for one from the subsidy list - AiFindSubsidyPassengerRoute(&fr); - if (IsInsideMM(fr.distance, 0, 55 + 1)) break; - - // try a random one - AiFindRandomPassengerRoute(&fr); - if (IsInsideMM(fr.distance, 0, 55 + 1)) break; - - // only test 60 times - if (--i == 0) return; - } - - fr.cargo = CT_PASSENGERS; - if (!AiCheckIfRouteIsGood(c, &fr, 1)) return; - - // Fill the source field - _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from); - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 7; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.unk6 = 1; - _companies_ai[c->index].src.unk7 = 0; - _companies_ai[c->index].src.buildcmd_a = 0x10; - _companies_ai[c->index].src.buildcmd_b = 0xFF; - _companies_ai[c->index].src.direction = AiGetDirectionBetweenTiles( - GET_TOWN_OR_INDUSTRY_TILE(fr.from), - GET_TOWN_OR_INDUSTRY_TILE(fr.to) - ); - _companies_ai[c->index].src.cargo = fr.cargo; - - // Fill the dest field - _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to); - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 7; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.unk6 = 1; - _companies_ai[c->index].dst.unk7 = 0; - _companies_ai[c->index].dst.buildcmd_a = 0xFF; - _companies_ai[c->index].dst.buildcmd_b = 0xFF; - _companies_ai[c->index].dst.direction = AiGetDirectionBetweenTiles( - GET_TOWN_OR_INDUSTRY_TILE(fr.to), - GET_TOWN_OR_INDUSTRY_TILE(fr.from) - ); - _companies_ai[c->index].dst.cargo = fr.cargo; - - // Fill common fields - _companies_ai[c->index].cargo_type = fr.cargo; - _companies_ai[c->index].num_wagons = 2; - _companies_ai[c->index].build_kind = 1; - _companies_ai[c->index].num_build_rec = 2; - _companies_ai[c->index].num_loco_to_build = 1; - _companies_ai[c->index].num_want_fullload = 0; - _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - _companies_ai[c->index].state = AIS_BUILD_DEFAULT_RAIL_BLOCKS; - _companies_ai[c->index].state_mode = UCHAR_MAX; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantTrainRoute(Company *c) -{ - uint16 r = GB(Random(), 0, 16); - - _companies_ai[c->index].railtype_to_use = GetBestRailtype(c->index); - - if (r > 0xD000) { - AiWantLongIndustryRoute(c); - } else if (r > 0x6000) { - AiWantMediumIndustryRoute(c); - } else if (r > 0x1000) { - AiWantShortIndustryRoute(c); - } else if (r > 0x800) { - AiWantPassengerRoute(c); - } else { - AiWantMailRoute(c); - } -} - -static void AiWantLongRoadIndustryRoute(Company *c) -{ - int i; - FoundRoute fr; - - i = 60; - for (;;) { - // look for one from the subsidy list - AiFindSubsidyIndustryRoute(&fr); - if (IsInsideMM(fr.distance, 35, 55 + 1)) break; - - // try a random one - AiFindRandomIndustryRoute(&fr); - if (IsInsideMM(fr.distance, 35, 55 + 1)) break; - - // only test 60 times - if (--i == 0) return; - } - - if (!AiCheckIfRouteIsGood(c, &fr, 2)) return; - - // Fill the source field - _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from); - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 9; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.buildcmd_a = 1; - _companies_ai[c->index].src.direction = 0; - _companies_ai[c->index].src.cargo = fr.cargo | 0x80; - - // Fill the dest field - _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to); - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 9; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.buildcmd_a = 0xFF; - _companies_ai[c->index].dst.direction = 0; - _companies_ai[c->index].dst.cargo = fr.cargo; - - // Fill common fields - _companies_ai[c->index].cargo_type = fr.cargo; - _companies_ai[c->index].num_build_rec = 2; - _companies_ai[c->index].num_loco_to_build = 5; - _companies_ai[c->index].num_want_fullload = 5; - -// _companies_ai[c->index].loco_id = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - - _companies_ai[c->index].state = AIS_BUILD_DEFAULT_ROAD_BLOCKS; - _companies_ai[c->index].state_mode = UCHAR_MAX; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantMediumRoadIndustryRoute(Company *c) -{ - int i; - FoundRoute fr; - - i = 60; - for (;;) { - // look for one from the subsidy list - AiFindSubsidyIndustryRoute(&fr); - if (IsInsideMM(fr.distance, 15, 40 + 1)) break; - - // try a random one - AiFindRandomIndustryRoute(&fr); - if (IsInsideMM(fr.distance, 15, 40 + 1)) break; - - // only test 60 times - if (--i == 0) return; - } - - if (!AiCheckIfRouteIsGood(c, &fr, 2)) return; - - // Fill the source field - _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from); - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 9; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.buildcmd_a = 1; - _companies_ai[c->index].src.direction = 0; - _companies_ai[c->index].src.cargo = fr.cargo | 0x80; - - // Fill the dest field - _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to); - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 9; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.buildcmd_a = 0xFF; - _companies_ai[c->index].dst.direction = 0; - _companies_ai[c->index].dst.cargo = fr.cargo; - - // Fill common fields - _companies_ai[c->index].cargo_type = fr.cargo; - _companies_ai[c->index].num_build_rec = 2; - _companies_ai[c->index].num_loco_to_build = 3; - _companies_ai[c->index].num_want_fullload = 3; - -// _companies_ai[c->index].loco_id = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - - _companies_ai[c->index].state = AIS_BUILD_DEFAULT_ROAD_BLOCKS; - _companies_ai[c->index].state_mode = UCHAR_MAX; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantLongRoadPassengerRoute(Company *c) -{ - int i; - FoundRoute fr; - - i = 60; - for (;;) { - // look for one from the subsidy list - AiFindSubsidyPassengerRoute(&fr); - if (IsInsideMM(fr.distance, 55, 180 + 1)) break; - - // try a random one - AiFindRandomPassengerRoute(&fr); - if (IsInsideMM(fr.distance, 55, 180 + 1)) break; - - // only test 60 times - if (--i == 0) return; - } - - fr.cargo = CT_PASSENGERS; - - if (!AiCheckIfRouteIsGood(c, &fr, 2)) return; - - // Fill the source field - _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to); - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 10; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.buildcmd_a = 1; - _companies_ai[c->index].src.direction = 0; - _companies_ai[c->index].src.cargo = CT_PASSENGERS; - - // Fill the dest field - _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from); - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 10; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.buildcmd_a = 0xFF; - _companies_ai[c->index].dst.direction = 0; - _companies_ai[c->index].dst.cargo = CT_PASSENGERS; - - // Fill common fields - _companies_ai[c->index].cargo_type = CT_PASSENGERS; - _companies_ai[c->index].num_build_rec = 2; - _companies_ai[c->index].num_loco_to_build = 4; - _companies_ai[c->index].num_want_fullload = 0; - -// _companies_ai[c->index].loco_id = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - - _companies_ai[c->index].state = AIS_BUILD_DEFAULT_ROAD_BLOCKS; - _companies_ai[c->index].state_mode = UCHAR_MAX; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantPassengerRouteInsideTown(Company *c) -{ - int i; - FoundRoute fr; - Town *t; - - i = 60; - for (;;) { - // Find a town big enough - t = AiFindRandomTown(); - if (t != NULL && t->population >= 700) break; - - // only test 60 times - if (--i == 0) return; - } - - fr.cargo = CT_PASSENGERS; - fr.from = fr.to = t; - - if (!AiCheckIfRouteIsGood(c, &fr, 2)) return; - - // Fill the source field - _companies_ai[c->index].src.spec_tile = t->xy; - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 10; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.buildcmd_a = 1; - _companies_ai[c->index].src.direction = 0; - _companies_ai[c->index].src.cargo = CT_PASSENGERS; - - // Fill the dest field - _companies_ai[c->index].dst.spec_tile = t->xy; - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 10; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.buildcmd_a = 0xFF; - _companies_ai[c->index].dst.direction = 0; - _companies_ai[c->index].dst.cargo = CT_PASSENGERS; - - // Fill common fields - _companies_ai[c->index].cargo_type = CT_PASSENGERS; - _companies_ai[c->index].num_build_rec = 2; - _companies_ai[c->index].num_loco_to_build = 2; - _companies_ai[c->index].num_want_fullload = 0; - -// _companies_ai[c->index].loco_id = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - - _companies_ai[c->index].state = AIS_BUILD_DEFAULT_ROAD_BLOCKS; - _companies_ai[c->index].state_mode = UCHAR_MAX; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantRoadRoute(Company *c) -{ - uint16 r = GB(Random(), 0, 16); - - if (r > 0x4000) { - AiWantLongRoadIndustryRoute(c); - } else if (r > 0x2000) { - AiWantMediumRoadIndustryRoute(c); - } else if (r > 0x1000) { - AiWantLongRoadPassengerRoute(c); - } else { - AiWantPassengerRouteInsideTown(c); - } -} - -static void AiWantPassengerAircraftRoute(Company *c) -{ - FoundRoute fr; - int i; - - /* Get aircraft that would be bought for this route - * (probably, as conditions may change before the route is fully built, - * like running out of money and having to select different aircraft, etc ...) */ - EngineID veh = AiChooseAircraftToBuild(c->money, _companies_ai[c->index].build_kind != 0 ? AIR_CTOL : 0); - - /* No aircraft buildable mean no aircraft route */ - if (veh == INVALID_ENGINE) return; - - const AircraftVehicleInfo *avi = AircraftVehInfo(veh); - - /* For passengers, "optimal" number of days in transit is about 80 to 100 - * Calculate "maximum optimal number of squares" from speed for 80 days - * 20 days should be enough for takeoff, land, taxi, etc ... - * - * "A vehicle traveling at 100kph will cross 5.6 tiles per day" -> - * Since in table aircraft speeds are in "real km/h", this should be accurate - * We get max_squares = avi->max_speed * 5.6 / 100.0 * 80 */ - int max_squares = avi->max_speed * 448 / 100; - - /* For example this will be 10456 tiles for 2334 km/h aircrafts with realistic aircraft speeds - * and 836 with "unrealistic" speeds, much more than the original 95 squares limit - * - * Size of the map, if not rectangular, it is the larger dimension of it - */ - int map_size = max(MapSizeX(), MapSizeY()); - - /* Minimum distance between airports is half of map size, clamped between 1% and 20% of optimum. - * May prevent building plane routes at all on small maps, but they will be ineffective there, so - * it is feature, not a bug. - * On smaller distances, buses or trains are usually more effective approach anyway. - * Additional safeguard is needing at least 20 squares, - * which may trigger in highly unusual configurations */ - int min_squares = max(20, max(max_squares / 100, min(max_squares / 5, map_size / 2))); - - /* Should not happen, unless aircraft with real speed under approx. 5 km/h is selected. - * No such exist, unless using some NewGRF with ballons, zeppelins or similar - * slow-moving stuff. In that case, bail out, it is faster to walk by foot anyway :). */ - if (max_squares < min_squares) return; - - i = 60; - for (;;) { - - // look for one from the subsidy list - AiFindSubsidyPassengerRoute(&fr); - if (IsInsideMM(fr.distance, min_squares, max_squares + 1)) break; - - // try a random one - AiFindRandomPassengerRoute(&fr); - if (IsInsideMM(fr.distance, min_squares, max_squares + 1)) break; - - // only test 60 times - if (--i == 0) return; - } - - fr.cargo = CT_PASSENGERS; - if (!AiCheckIfRouteIsGood(c, &fr, 4)) return; - - - // Fill the source field - _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to); - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 12; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.cargo = fr.cargo; - - // Fill the dest field - _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from); - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 12; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.cargo = fr.cargo; - - // Fill common fields - _companies_ai[c->index].cargo_type = fr.cargo; - _companies_ai[c->index].build_kind = 0; - _companies_ai[c->index].num_build_rec = 2; - _companies_ai[c->index].num_loco_to_build = 1; - /* Using full load always may not be the best. - * Pick random value and rely on selling the vehicle & route - * afterwards if the choice was utterly wrong (or maybe altering the value if AI is improved) - * When traffic is very low or very assymetric, is is better not to full load - * When traffic is high, full/non-full make no difference - * It should be better to run with aircraft only one way full 6 times per year, - * rather than two way full 1 times. - * Practical experiments with AI show that the non-full-load aircrafts are usually - * those that survive - * Also, non-full load is more resistant against starving (by building better stations - * or using exclusive rights) - */ - _companies_ai[c->index].num_want_fullload = Chance16(1, 5); // 20% chance -// _companies_ai[c->index].loco_id = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - - _companies_ai[c->index].state = AIS_AIRPORT_STUFF; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantOilRigAircraftRoute(Company *c) -{ - int i; - FoundRoute fr; - Town *t; - Industry *in; - - i = 60; - for (;;) { - // Find a town - t = AiFindRandomTown(); - if (t != NULL) { - // Find a random oil rig industry - in = AiFindRandomIndustry(); - if (in != NULL && GetIndustrySpec(in->type)->behaviour & INDUSTRYBEH_AI_AIRSHIP_ROUTES) { - if (DistanceManhattan(t->xy, in->xy) < 60) - break; - } - } - - // only test 60 times - if (--i == 0) return; - } - - fr.cargo = CT_PASSENGERS; - fr.from = fr.to = t; - - if (!AiCheckIfRouteIsGood(c, &fr, 4)) return; - - // Fill the source field - _companies_ai[c->index].src.spec_tile = t->xy; - _companies_ai[c->index].src.use_tile = 0; - _companies_ai[c->index].src.rand_rng = 12; - _companies_ai[c->index].src.cur_building_rule = 0xFF; - _companies_ai[c->index].src.cargo = CT_PASSENGERS; - - // Fill the dest field - _companies_ai[c->index].dst.spec_tile = in->xy; - _companies_ai[c->index].dst.use_tile = 0; - _companies_ai[c->index].dst.rand_rng = 5; - _companies_ai[c->index].dst.cur_building_rule = 0xFF; - _companies_ai[c->index].dst.cargo = CT_PASSENGERS; - - // Fill common fields - _companies_ai[c->index].cargo_type = CT_PASSENGERS; - _companies_ai[c->index].build_kind = 1; - _companies_ai[c->index].num_build_rec = 2; - _companies_ai[c->index].num_loco_to_build = 1; - _companies_ai[c->index].num_want_fullload = 0; -// _companies_ai[c->index].loco_id = INVALID_VEHICLE; - _companies_ai[c->index].order_list_blocks[0] = 0; - _companies_ai[c->index].order_list_blocks[1] = 1; - _companies_ai[c->index].order_list_blocks[2] = 255; - - _companies_ai[c->index].state = AIS_AIRPORT_STUFF; - _companies_ai[c->index].timeout_counter = 0; -} - -static void AiWantAircraftRoute(Company *c) -{ - uint16 r = (uint16)Random(); - - if (r >= 0x2AAA || _date < 0x3912 + DAYS_TILL_ORIGINAL_BASE_YEAR) { - AiWantPassengerAircraftRoute(c); - } else { - AiWantOilRigAircraftRoute(c); - } -} - - - -static void AiStateWantNewRoute(Company *c) -{ - uint16 r; - int i; - - if (c->money < AiGetBasePrice(c) * 500) { - _companies_ai[c->index].state = AIS_0; - return; - } - - i = 200; - for (;;) { - r = (uint16)Random(); - - if (_settings_game.ai.ai_disable_veh_train && - _settings_game.ai.ai_disable_veh_roadveh && - _settings_game.ai.ai_disable_veh_aircraft && - _settings_game.ai.ai_disable_veh_ship) { - return; - } - - if (r < 0x7626) { - if (_settings_game.ai.ai_disable_veh_train) continue; - AiWantTrainRoute(c); - } else if (r < 0xC4EA) { - if (_settings_game.ai.ai_disable_veh_roadveh) continue; - AiWantRoadRoute(c); - } else if (r < 0xD89B) { - if (_settings_game.ai.ai_disable_veh_aircraft) continue; - AiWantAircraftRoute(c); - } else { - /* Ships are not implemented in this (broken) AI */ - } - - // got a route? - if (_companies_ai[c->index].state != AIS_WANT_NEW_ROUTE) break; - - // time out? - if (--i == 0) { - if (++_companies_ai[c->index].state_counter == 556) _companies_ai[c->index].state = AIS_0; - break; - } - } -} - -static bool AiCheckTrackResources(TileIndex tile, const AiDefaultBlockData *p, byte cargo) -{ - uint rad = (_settings_game.station.modified_catchment) ? CA_TRAIN : CA_UNMODIFIED; - - for (; p->mode != 4; p++) { - AcceptedCargo values; - TileIndex tile2; - uint w; - uint h; - - if (p->mode != 1) continue; - - tile2 = TILE_ADD(tile, ToTileIndexDiff(p->tileoffs)); - w = GB(p->attr, 1, 3); - h = GB(p->attr, 4, 3); - - if (p->attr & 1) Swap(w, h); - - if (cargo & 0x80) { - GetProductionAroundTiles(values, tile2, w, h, rad); - return values[cargo & 0x7F] != 0; - } else { - GetAcceptanceAroundTiles(values, tile2, w, h, rad); - if (!(values[cargo] & ~7)) - return false; - if (cargo != CT_MAIL) - return true; - return !!((values[cargo] >> 1) & ~7); - } - } - - return true; -} - -static CommandCost AiDoBuildDefaultRailTrack(TileIndex tile, const AiDefaultBlockData *p, RailType railtype, uint32 flag) -{ - CommandCost ret; - CommandCost total_cost(EXPENSES_CONSTRUCTION); - Town *t = NULL; - int rating = 0; - int i, j, k; - - for (;;) { - // This will seldomly overflow for valid reasons. Mask it to be on the safe side. - uint c = TILE_MASK(tile + ToTileIndexDiff(p->tileoffs)); - - _cleared_town = NULL; - - if (p->mode < 2) { - if (p->mode == 0) { - // Depot - ret = DoCommand(c, railtype, p->attr, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_TRAIN_DEPOT); - } else { - // Station - ret = DoCommand(c, (railtype & 0x0f) | (p->attr & 1) << 4 | (p->attr >> 4) << 8 | (p->attr >> 1 & 7) << 16, (INVALID_STATION << 16), flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_RAILROAD_STATION); - } - - if (CmdFailed(ret)) return CMD_ERROR; - total_cost.AddCost(ret); - -clear_town_stuff:; - if (_cleared_town != NULL) { - if (t != NULL && t != _cleared_town) - return CMD_ERROR; - t = _cleared_town; - rating += _cleared_town_rating; - } - } else if (p->mode == 2) { - /* Rail */ - if (IsTileType(c, MP_RAILWAY)) return CMD_ERROR; - - j = p->attr; - k = 0; - - /* Build the rail - * note: FOR_EACH_SET_BIT cannot be used here - */ - for (i = 0; i != 6; i++, j >>= 1) { - if (j & 1) { - k = i; - ret = DoCommand(c, railtype, i, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_SINGLE_RAIL); - if (CmdFailed(ret)) return CMD_ERROR; - total_cost.AddCost(ret); - } - } - - /* signals too? */ - if (j & 3) { - // Can't build signals on a road. - if (IsTileType(c, MP_ROAD)) return CMD_ERROR; - - if (flag & DC_EXEC) { - j = 4 - j; - do { - ret = DoCommand(c, k, 0, flag, CMD_BUILD_SIGNALS); - } while (--j); - } else { - ret.AddCost(_price.build_signals); - } - if (CmdFailed(ret)) return CMD_ERROR; - total_cost.AddCost(ret); - } - } else if (p->mode == 3) { - //Clear stuff and then build single rail. - if (GetTileSlope(c, NULL) != SLOPE_FLAT) return CMD_ERROR; - ret = DoCommand(c, 0, 0, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_LANDSCAPE_CLEAR); - if (CmdFailed(ret)) return CMD_ERROR; - total_cost.AddCost(ret); - total_cost.AddCost(_price.build_rail); - - if (flag & DC_EXEC) { - DoCommand(c, railtype, p->attr & 1, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_SINGLE_RAIL); - } - - goto clear_town_stuff; - } else { - // Unk - break; - } - - p++; - } - - if (!(flag & DC_EXEC)) { - if (t != NULL && rating > t->ratings[_current_company]) { - return CMD_ERROR; - } - } - - return total_cost; -} - -// Returns rule and cost -static int AiBuildDefaultRailTrack(TileIndex tile, byte p0, byte p1, byte p2, byte p3, byte dir, byte cargo, RailType railtype, CommandCost *cost) -{ - int i; - const AiDefaultRailBlock *p; - - for (i = 0; (p = _default_rail_track_data[i]) != NULL; i++) { - if (p->p0 == p0 && p->p1 == p1 && p->p2 == p2 && p->p3 == p3 && - (p->dir == 0xFF || p->dir == dir || ((p->dir - 1) & 3) == dir)) { - *cost = AiDoBuildDefaultRailTrack(tile, p->data, railtype, DC_NO_TOWN_RATING); - if (CmdSucceeded(*cost) && AiCheckTrackResources(tile, p->data, cargo)) - return i; - } - } - - return -1; -} - -static const byte _terraform_up_flags[] = { - 14, 13, 12, 11, - 10, 9, 8, 7, - 6, 5, 4, 3, - 2, 1, 0, 1, - 2, 1, 4, 1, - 2, 1, 8, 1, - 2, 1, 4, 2, - 2, 1 -}; - -static const byte _terraform_down_flags[] = { - 1, 2, 3, 4, - 5, 6, 1, 8, - 9, 10, 8, 12, - 4, 2, 0, 0, - 1, 2, 3, 4, - 5, 6, 2, 8, - 9, 10, 1, 12, - 8, 4 -}; - -static void AiDoTerraformLand(TileIndex tile, DiagDirection dir, int unk, int mode) -{ - CompanyID old_company; - uint32 r; - Slope slope; - uint h; - - old_company = _current_company; - _current_company = OWNER_NONE; - - r = Random(); - - unk &= (int)r; - - do { - tile = TILE_MASK(tile + TileOffsByDiagDir(dir)); - - r >>= 2; - if (r & 2) { - dir = ChangeDiagDir(dir, (r & 1) ? DIAGDIRDIFF_90LEFT : DIAGDIRDIFF_90RIGHT); - } - } while (--unk >= 0); - - slope = GetTileSlope(tile, &h); - - if (slope != SLOPE_FLAT) { - if (mode > 0 || (mode == 0 && !(r & 0xC))) { - // Terraform up - DoCommand(tile, _terraform_up_flags[slope - 1], 1, - DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND); - } else if (h != 0) { - // Terraform down - DoCommand(tile, _terraform_down_flags[slope - 1], 0, - DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND); - } - } - - _current_company = old_company; -} - -static void AiStateBuildDefaultRailBlocks(Company *c) -{ - uint i; - int j; - AiBuildRec *aib; - int rule; - CommandCost cost; - - // time out? - if (++_companies_ai[c->index].timeout_counter == 1388) { - _companies_ai[c->index].state = AIS_DELETE_RAIL_BLOCKS; - return; - } - - // do the following 8 times - for (i = 0; i < 8; i++) { - // check if we can build the default track - aib = &_companies_ai[c->index].src; - j = _companies_ai[c->index].num_build_rec; - do { - // this item has already been built? - if (aib->cur_building_rule != 255) continue; - - // adjust the coordinate randomly, - // to make sure that we find a position. - aib->use_tile = AdjustTileCoordRandomly(aib->spec_tile, aib->rand_rng); - - // check if the track can be build there. - rule = AiBuildDefaultRailTrack(aib->use_tile, - _companies_ai[c->index].build_kind, _companies_ai[c->index].num_wagons, - aib->unk6, aib->unk7, - aib->direction, aib->cargo, - _companies_ai[c->index].railtype_to_use, - &cost - ); - - if (rule == -1) { - // cannot build, terraform after a while - if (_companies_ai[c->index].state_counter >= 600) { - AiDoTerraformLand(aib->use_tile, (DiagDirection)(Random() & 3), 3, (int8)_companies_ai[c->index].state_mode); - } - // also try the other terraform direction - if (++_companies_ai[c->index].state_counter >= 1000) { - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].state_mode = -_companies_ai[c->index].state_mode; - } - } else if (CheckCompanyHasMoney(cost)) { - // company has money, build it. - aib->cur_building_rule = rule; - - AiDoBuildDefaultRailTrack( - aib->use_tile, - _default_rail_track_data[rule]->data, - _companies_ai[c->index].railtype_to_use, - DC_EXEC | DC_NO_TOWN_RATING - ); - } - } while (++aib, --j); - } - - // check if we're done with all of them - aib = &_companies_ai[c->index].src; - j = _companies_ai[c->index].num_build_rec; - do { - if (aib->cur_building_rule == 255) return; - } while (++aib, --j); - - // yep, all are done. switch state to the rail building state. - _companies_ai[c->index].state = AIS_BUILD_RAIL; - _companies_ai[c->index].state_mode = 255; -} - -static TileIndex AiGetEdgeOfDefaultRailBlock(byte rule, TileIndex tile, byte cmd, DiagDirection *dir) -{ - const AiDefaultBlockData *p = _default_rail_track_data[rule]->data; - - while (p->mode != 3 || !((--cmd) & 0x80)) p++; - - return tile + ToTileIndexDiff(p->tileoffs) - TileOffsByDiagDir(*dir = p->attr); -} - -struct AiRailPathFindData { - TileIndex tile; - TileIndex tile2; - int count; - bool flag; -}; - -static bool AiEnumFollowTrack(TileIndex tile, AiRailPathFindData *a, int track, uint length) -{ - if (a->flag) return true; - - if (length > 20 || tile == a->tile) { - a->flag = true; - return true; - } - - if (DistanceMax(tile, a->tile2) < 4) a->count++; - - return false; -} - -static bool AiDoFollowTrack(const Company *c) -{ - AiRailPathFindData arpfd; - - arpfd.tile = _companies_ai[c->index].start_tile_a; - arpfd.tile2 = _companies_ai[c->index].cur_tile_a; - arpfd.flag = false; - arpfd.count = 0; - FollowTrack(_companies_ai[c->index].cur_tile_a + TileOffsByDiagDir(_companies_ai[c->index].cur_dir_a), PATHFIND_FLAGS_NONE, TRANSPORT_RAIL, 0, ReverseDiagDir(_companies_ai[c->index].cur_dir_a), - (TPFEnumProc*)AiEnumFollowTrack, NULL, &arpfd); - return arpfd.count > 8; -} - -struct AiRailFinder { - TileIndex final_tile; - DiagDirection final_dir; - byte depth; - byte recursive_mode; - DiagDirection cur_best_dir; - DiagDirection best_dir; - byte cur_best_depth; - byte best_depth; - uint cur_best_dist; - const byte *best_ptr; - uint best_dist; - TileIndex cur_best_tile, best_tile; - TileIndex bridge_end_tile; - Company *company; -}; - -static const byte _ai_table_15[4][8] = { - {0, 0, 4, 3, 3, 1, 128 + 0, 64}, - {1, 1, 2, 0, 4, 2, 128 + 1, 65}, - {0, 2, 2, 3, 5, 1, 128 + 2, 66}, - {1, 3, 5, 0, 3, 2, 128 + 3, 67} -}; - - -static bool AiIsTileBanned(const Company *c, TileIndex tile, byte val) -{ - int i; - - for (i = 0; i != _companies_ai[c->index].banned_tile_count; i++) { - if (_companies_ai[c->index].banned_tiles[i] == tile && _companies_ai[c->index].banned_val[i] == val) { - return true; - } - } - return false; -} - -static void AiBanTile(Company *c, TileIndex tile, byte val) -{ - uint i; - - for (i = lengthof(_companies_ai[c->index].banned_tiles) - 1; i != 0; i--) { - _companies_ai[c->index].banned_tiles[i] = _companies_ai[c->index].banned_tiles[i - 1]; - _companies_ai[c->index].banned_val[i] = _companies_ai[c->index].banned_val[i - 1]; - } - - _companies_ai[c->index].banned_tiles[0] = tile; - _companies_ai[c->index].banned_val[0] = val; - - if (_companies_ai[c->index].banned_tile_count != lengthof(_companies_ai[c->index].banned_tiles)) { - _companies_ai[c->index].banned_tile_count++; - } -} - -static void AiBuildRailRecursive(AiRailFinder *arf, TileIndex tile, DiagDirection dir); - -static bool AiCheckRailPathBetter(AiRailFinder *arf, const byte *p) -{ - bool better = false; - - if (arf->recursive_mode < 1) { - // Mode is 0. This means destination has not been found yet. - // If the found path is shorter than the current one, remember it. - if (arf->cur_best_dist < arf->best_dist) { - arf->best_dir = arf->cur_best_dir; - arf->best_dist = arf->cur_best_dist; - arf->best_ptr = p; - arf->best_tile = arf->cur_best_tile; - better = true; - } - } else if (arf->recursive_mode > 1) { - // Mode is 2. - if (arf->best_dist != 0 || arf->cur_best_depth < arf->best_depth) { - arf->best_depth = arf->cur_best_depth; - arf->best_dist = 0; - arf->best_ptr = p; - arf->best_tile = 0; - better = true; - } - } - arf->recursive_mode = 0; - arf->cur_best_dist = UINT_MAX; - arf->cur_best_depth = 0xff; - - return better; -} - -static inline void AiCheckBuildRailBridgeHere(AiRailFinder *arf, TileIndex tile, const byte *p) -{ - Slope tileh; - uint z; - bool flag; - - DiagDirection dir2 = (DiagDirection)(p[0] & 3); - - tileh = GetTileSlope(tile, &z); - if (tileh == InclinedSlope(ReverseDiagDir(dir2)) || (tileh == SLOPE_FLAT && z != 0)) { - TileIndex tile_new = tile; - - // Allow bridges directly over bottom tiles - flag = z == 0; - for (;;) { - TileType type; - - if ((TileIndexDiff)tile_new < -TileOffsByDiagDir(dir2)) return; // Wraping around map, no bridge possible! - tile_new = TILE_MASK(tile_new + TileOffsByDiagDir(dir2)); - type = GetTileType(tile_new); - - if (type == MP_CLEAR || type == MP_TREES || GetTileSlope(tile_new, NULL) != SLOPE_FLAT) { - if (!flag) return; - break; - } - if (type != MP_WATER && type != MP_RAILWAY && type != MP_ROAD) return; - flag = true; - } - - // Is building a (rail)bridge possible at this place (type doesn't matter)? - if (CmdFailed(DoCommand(tile_new, tile, _companies_ai[arf->company->index].railtype_to_use << 8 | TRANSPORT_RAIL << 15, DC_AUTO, CMD_BUILD_BRIDGE))) { - return; - } - AiBuildRailRecursive(arf, tile_new, dir2); - - // At the bottom depth, check if the new path is better than the old one. - if (arf->depth == 1) { - if (AiCheckRailPathBetter(arf, p)) arf->bridge_end_tile = tile_new; - } - } -} - -static inline void AiCheckBuildRailTunnelHere(AiRailFinder *arf, TileIndex tile, const byte *p) -{ - uint z; - - if (GetTileSlope(tile, &z) == InclinedSlope((DiagDirection)(p[0] & 3)) && z != 0) { - CommandCost cost = DoCommand(tile, _companies_ai[arf->company->index].railtype_to_use, 0, DC_AUTO, CMD_BUILD_TUNNEL); - - if (CmdSucceeded(cost) && cost.GetCost() <= (arf->company->money >> 4)) { - AiBuildRailRecursive(arf, _build_tunnel_endtile, (DiagDirection)(p[0] & 3)); - if (arf->depth == 1) AiCheckRailPathBetter(arf, p); - } - } -} - - -static void AiBuildRailRecursive(AiRailFinder *arf, TileIndex tile, DiagDirection dir) -{ - const byte *p; - - tile = TILE_MASK(tile + TileOffsByDiagDir(dir)); - - // Reached destination? - if (tile == arf->final_tile) { - if (arf->final_dir != ReverseDiagDir(dir)) { - if (arf->recursive_mode != 2) arf->recursive_mode = 1; - } else if (arf->recursive_mode != 2) { - arf->recursive_mode = 2; - arf->cur_best_depth = arf->depth; - } else { - if (arf->depth < arf->cur_best_depth) arf->cur_best_depth = arf->depth; - } - return; - } - - // Depth too deep? - if (arf->depth >= 4) { - uint dist = DistanceMaxPlusManhattan(tile, arf->final_tile); - - if (dist < arf->cur_best_dist) { - // Store the tile that is closest to the final position. - arf->cur_best_depth = arf->depth; - arf->cur_best_dist = dist; - arf->cur_best_tile = tile; - arf->cur_best_dir = dir; - } - return; - } - - // Increase recursion depth - arf->depth++; - - // Grab pointer to list of stuff that is possible to build - p = _ai_table_15[dir]; - - // Try to build a single rail in all directions. - if (GetTileZ(tile) == 0) { - p += 6; - } else { - do { - // Make sure the tile is not in the list of banned tiles and that a rail can be built here. - if (!AiIsTileBanned(arf->company, tile, p[0]) && - CmdSucceeded(DoCommand(tile, _companies_ai[arf->company->index].railtype_to_use, p[0], DC_AUTO | DC_NO_WATER | DC_NO_RAIL_OVERLAP, CMD_BUILD_SINGLE_RAIL))) { - AiBuildRailRecursive(arf, tile, (DiagDirection)p[1]); - } - - // At the bottom depth? - if (arf->depth == 1) AiCheckRailPathBetter(arf, p); - - p += 2; - } while (!(p[0] & 0x80)); - } - - AiCheckBuildRailBridgeHere(arf, tile, p); - AiCheckBuildRailTunnelHere(arf, tile, p + 1); - - arf->depth--; -} - - -static void AiBuildRailConstruct(Company *c) -{ - AiRailFinder arf; - int i; - - // Check too much lookahead? - if (AiDoFollowTrack(c)) { - _companies_ai[c->index].state_counter = (Random()&0xE)+6; // Destruct this amount of blocks - _companies_ai[c->index].state_mode = 1; // Start destruct - - // Ban this tile and don't reach it for a while. - AiBanTile(c, _companies_ai[c->index].cur_tile_a, FindFirstBit(GetRailTrackStatus(_companies_ai[c->index].cur_tile_a))); - return; - } - - // Setup recursive finder and call it. - arf.company = c; - arf.final_tile = _companies_ai[c->index].cur_tile_b; - arf.final_dir = _companies_ai[c->index].cur_dir_b; - arf.depth = 0; - arf.recursive_mode = 0; - arf.best_ptr = NULL; - arf.cur_best_dist = UINT_MAX; - arf.cur_best_depth = 0xff; - arf.best_dist = UINT_MAX; - arf.best_depth = 0xff; - arf.cur_best_tile = 0; - arf.best_tile = 0; - AiBuildRailRecursive(&arf, _companies_ai[c->index].cur_tile_a, _companies_ai[c->index].cur_dir_a); - - // Reached destination? - if (arf.recursive_mode == 2 && arf.cur_best_depth == 0) { - _companies_ai[c->index].state_mode = 255; - return; - } - - // Didn't find anything to build? - if (arf.best_ptr == NULL) { - // Terraform some - for (i = 0; i != 5; i++) { - AiDoTerraformLand(_companies_ai[c->index].cur_tile_a, _companies_ai[c->index].cur_dir_a, 3, 0); - } - - if (++_companies_ai[c->index].state_counter == 21) { - _companies_ai[c->index].state_counter = 40; - _companies_ai[c->index].state_mode = 1; - - // Ban this tile - AiBanTile(c, _companies_ai[c->index].cur_tile_a, FindFirstBit(GetRailTrackStatus(_companies_ai[c->index].cur_tile_a))); - } - return; - } - - _companies_ai[c->index].cur_tile_a += TileOffsByDiagDir(_companies_ai[c->index].cur_dir_a); - - if (arf.best_ptr[0] & 0x80) { - TileIndex t1 = _companies_ai[c->index].cur_tile_a; - TileIndex t2 = arf.bridge_end_tile; - - int32 bridge_len = GetTunnelBridgeLength(t1, t2); - - DiagDirection dir = (TileX(t1) == TileX(t2) ? DIAGDIR_SE : DIAGDIR_SW); - Track track = DiagDirToDiagTrack(dir); - - if (t2 < t1) dir = ReverseDiagDir(dir); - - /* try to build a long rail instead of bridge... */ - bool fail = false; - CommandCost cost; - TileIndex t = t1; - - /* try to build one rail on each tile - can't use CMD_BUILD_RAILROAD_TRACK now, it can build one part of track without failing */ - do { - cost = DoCommand(t, _companies_ai[c->index].railtype_to_use, track, DC_AUTO | DC_NO_WATER, CMD_BUILD_SINGLE_RAIL); - /* do not allow building over existing track */ - if (CmdFailed(cost) || IsTileType(t, MP_RAILWAY)) { - fail = true; - break; - } - t += TileOffsByDiagDir(dir); - } while (t != t2); - - /* can we build long track? */ - if (!fail) cost = DoCommand(t1, t2, _companies_ai[c->index].railtype_to_use | (track << 4), DC_AUTO | DC_NO_WATER, CMD_BUILD_RAILROAD_TRACK); - - if (!fail && CmdSucceeded(cost) && cost.GetCost() <= c->money) { - DoCommand(t1, t2, _companies_ai[c->index].railtype_to_use | (track << 4), DC_AUTO | DC_NO_WATER | DC_EXEC, CMD_BUILD_RAILROAD_TRACK); - } else { - - /* Figure out which (rail)bridge type to build - * start with best bridge, then go down to worse and worse bridges - * unnecessary to check for worst bridge (i=0), since AI will always build that. */ - int i; - for (i = MAX_BRIDGES - 1; i != 0; i--) { - if (CheckBridge_Stuff(i, bridge_len)) { - CommandCost cost = DoCommand(t1, t2, i | _companies_ai[c->index].railtype_to_use << 8 | TRANSPORT_RAIL << 15, DC_AUTO, CMD_BUILD_BRIDGE); - if (CmdSucceeded(cost) && cost.GetCost() < (c->money >> 1) && cost.GetCost() < ((c->money + _economy.max_loan - c->current_loan) >> 5)) break; - } - } - - /* Build it */ - DoCommand(t1, t2, i | _companies_ai[c->index].railtype_to_use << 8 | TRANSPORT_RAIL << 15, DC_AUTO | DC_EXEC, CMD_BUILD_BRIDGE); - } - - _companies_ai[c->index].cur_tile_a = t2; - _companies_ai[c->index].state_counter = 0; - } else if (arf.best_ptr[0] & 0x40) { - // tunnel - DoCommand(_companies_ai[c->index].cur_tile_a, _companies_ai[c->index].railtype_to_use, 0, DC_AUTO | DC_EXEC, CMD_BUILD_TUNNEL); - _companies_ai[c->index].cur_tile_a = _build_tunnel_endtile; - _companies_ai[c->index].state_counter = 0; - } else { - // rail - _companies_ai[c->index].cur_dir_a = (DiagDirection)(arf.best_ptr[1] & 3); - DoCommand(_companies_ai[c->index].cur_tile_a, _companies_ai[c->index].railtype_to_use, arf.best_ptr[0], - DC_EXEC | DC_AUTO | DC_NO_WATER | DC_NO_RAIL_OVERLAP, CMD_BUILD_SINGLE_RAIL); - _companies_ai[c->index].state_counter = 0; - } - - if (arf.best_tile != 0) { - for (i = 0; i != 2; i++) { - AiDoTerraformLand(arf.best_tile, arf.best_dir, 3, 0); - } - } -} - -static bool AiRemoveTileAndGoForward(Company *c) -{ - const byte *ptr; - TileIndex tile = _companies_ai[c->index].cur_tile_a; - TileIndex tilenew; - - if (IsTileType(tile, MP_TUNNELBRIDGE)) { - if (IsTunnel(tile)) { - // Clear the tunnel and continue at the other side of it. - if (CmdFailed(DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) - return false; - _companies_ai[c->index].cur_tile_a = TILE_MASK(_build_tunnel_endtile - TileOffsByDiagDir(_companies_ai[c->index].cur_dir_a)); - return true; - } else { // IsBridge(tile) - // Check if the bridge points in the right direction. - // This is not really needed the first place AiRemoveTileAndGoForward is called. - if (DiagDirToAxis(GetTunnelBridgeDirection(tile)) != (_companies_ai[c->index].cur_dir_a & 1)) return false; - - tile = GetOtherBridgeEnd(tile); - - tilenew = TILE_MASK(tile - TileOffsByDiagDir(_companies_ai[c->index].cur_dir_a)); - // And clear the bridge. - if (CmdFailed(DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) - return false; - _companies_ai[c->index].cur_tile_a = tilenew; - return true; - } - } - - // Find the railtype at the position. Quit if no rail there. - TrackBits bits = GetRailTrackStatus(tile) & DiagdirReachesTracks(ReverseDiagDir(_companies_ai[c->index].cur_dir_a)); - if (bits == TRACK_BIT_NONE) return false; - - // Convert into a bit position that CMD_REMOVE_SINGLE_RAIL expects. - Track track = FindFirstTrack(bits); - - // Then remove and signals if there are any. - if (IsTileType(tile, MP_RAILWAY) && - GetRailTileType(tile) == RAIL_TILE_SIGNALS) { - DoCommand(tile, 0, 0, DC_EXEC, CMD_REMOVE_SIGNALS); - } - - // And also remove the rail. - if (CmdFailed(DoCommand(tile, 0, track, DC_EXEC, CMD_REMOVE_SINGLE_RAIL))) - return false; - - // Find the direction at the other edge of the rail. - ptr = _ai_table_15[ReverseDiagDir(_companies_ai[c->index].cur_dir_a)]; - while (ptr[0] != track) ptr += 2; - _companies_ai[c->index].cur_dir_a = ReverseDiagDir((DiagDirection)ptr[1]); - - // And then also switch tile. - _companies_ai[c->index].cur_tile_a = TILE_MASK(_companies_ai[c->index].cur_tile_a - TileOffsByDiagDir(_companies_ai[c->index].cur_dir_a)); - - return true; -} - - -static void AiBuildRailDestruct(Company *c) -{ - // Decrease timeout. - if (!--_companies_ai[c->index].state_counter) { - _companies_ai[c->index].state_mode = 2; - _companies_ai[c->index].state_counter = 0; - } - - // Don't do anything if the destination is already reached. - if (_companies_ai[c->index].cur_tile_a == _companies_ai[c->index].start_tile_a) return; - - AiRemoveTileAndGoForward(c); -} - - -static void AiBuildRail(Company *c) -{ - switch (_companies_ai[c->index].state_mode) { - case 0: // Construct mode, build new rail. - AiBuildRailConstruct(c); - break; - - case 1: // Destruct mode, destroy the rail currently built. - AiBuildRailDestruct(c); - break; - - case 2: { - uint i; - - // Terraform some and then try building again. - for (i = 0; i != 4; i++) { - AiDoTerraformLand(_companies_ai[c->index].cur_tile_a, _companies_ai[c->index].cur_dir_a, 3, 0); - } - - if (++_companies_ai[c->index].state_counter == 4) { - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].state_mode = 0; - } - } - - default: break; - } -} - -static void AiStateBuildRail(Company *c) -{ - int num; - AiBuildRec *aib; - byte cmd; - TileIndex tile; - DiagDirection dir; - - // time out? - if (++_companies_ai[c->index].timeout_counter == 1388) { - _companies_ai[c->index].state = AIS_DELETE_RAIL_BLOCKS; - return; - } - - // Currently building a rail between two points? - if (_companies_ai[c->index].state_mode != 255) { - AiBuildRail(c); - - // Alternate between edges - Swap(_companies_ai[c->index].start_tile_a, _companies_ai[c->index].start_tile_b); - Swap(_companies_ai[c->index].cur_tile_a, _companies_ai[c->index].cur_tile_b); - Swap(_companies_ai[c->index].start_dir_a, _companies_ai[c->index].start_dir_b); - Swap(_companies_ai[c->index].cur_dir_a, _companies_ai[c->index].cur_dir_b); - return; - } - - // Now, find two new points to build between - num = _companies_ai[c->index].num_build_rec; - aib = &_companies_ai[c->index].src; - - for (;;) { - cmd = aib->buildcmd_a; - aib->buildcmd_a = 255; - if (cmd != 255) break; - - cmd = aib->buildcmd_b; - aib->buildcmd_b = 255; - if (cmd != 255) break; - - aib++; - if (--num == 0) { - _companies_ai[c->index].state = AIS_BUILD_RAIL_VEH; - _companies_ai[c->index].state_counter = 0; // timeout - return; - } - } - - // Find first edge to build from. - tile = AiGetEdgeOfDefaultRailBlock(aib->cur_building_rule, aib->use_tile, cmd & 3, &dir); - _companies_ai[c->index].start_tile_a = tile; - _companies_ai[c->index].cur_tile_a = tile; - _companies_ai[c->index].start_dir_a = dir; - _companies_ai[c->index].cur_dir_a = dir; - DoCommand(TILE_MASK(tile + TileOffsByDiagDir(dir)), 0, (dir & 1) ? 1 : 0, DC_EXEC, CMD_REMOVE_SINGLE_RAIL); - - assert(TILE_MASK(tile) != 0xFF00); - - // Find second edge to build to - aib = (&_companies_ai[c->index].src) + ((cmd >> 4) & 0xF); - tile = AiGetEdgeOfDefaultRailBlock(aib->cur_building_rule, aib->use_tile, (cmd >> 2) & 3, &dir); - _companies_ai[c->index].start_tile_b = tile; - _companies_ai[c->index].cur_tile_b = tile; - _companies_ai[c->index].start_dir_b = dir; - _companies_ai[c->index].cur_dir_b = dir; - DoCommand(TILE_MASK(tile + TileOffsByDiagDir(dir)), 0, (dir & 1) ? 1 : 0, DC_EXEC, CMD_REMOVE_SINGLE_RAIL); - - assert(TILE_MASK(tile) != 0xFF00); - - // And setup state. - _companies_ai[c->index].state_mode = 2; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].banned_tile_count = 0; -} - -static StationID AiGetStationIdByDef(TileIndex tile, int id) -{ - const AiDefaultBlockData *p = _default_rail_track_data[id]->data; - while (p->mode != 1) p++; - return GetStationIndex(TILE_ADD(tile, ToTileIndexDiff(p->tileoffs))); -} - -static EngineID AiFindBestWagon(CargoID cargo, RailType railtype) -{ - EngineID best_veh_index = INVALID_ENGINE; - uint16 best_capacity = 0; - uint16 best_speed = 0; - uint speed; - const Engine *e; - - FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) { - EngineID i = e->index; - const RailVehicleInfo *rvi = &e->u.rail; - - if (!IsCompatibleRail(rvi->railtype, railtype) || - rvi->railveh_type != RAILVEH_WAGON || - !HasBit(e->company_avail, _current_company)) { - continue; - } - - if (rvi->cargo_type != cargo) continue; - - /* max_speed of 0 indicates no speed limit */ - speed = rvi->max_speed == 0 ? 0xFFFF : rvi->max_speed; - - if (rvi->capacity >= best_capacity && speed >= best_speed) { - best_capacity = rvi->capacity; - best_speed = best_speed; - best_veh_index = i; - } - } - - return best_veh_index; -} - -static void AiStateBuildRailVeh(Company *c) -{ - const AiDefaultBlockData *ptr; - TileIndex tile; - EngineID veh; - int i; - CargoID cargo; - CommandCost cost; - Vehicle *v; - VehicleID loco_id; - - ptr = _default_rail_track_data[_companies_ai[c->index].src.cur_building_rule]->data; - while (ptr->mode != 0) ptr++; - - tile = TILE_ADD(_companies_ai[c->index].src.use_tile, ToTileIndexDiff(ptr->tileoffs)); - - - cargo = _companies_ai[c->index].cargo_type; - for (i = 0;;) { - if (_companies_ai[c->index].wagon_list[i] == INVALID_VEHICLE) { - veh = AiFindBestWagon(cargo, _companies_ai[c->index].railtype_to_use); - /* veh will return INVALID_ENGINE if no suitable wagon is available. - * We shall treat this in the same way as having no money */ - if (veh == INVALID_ENGINE) goto handle_nocash; - cost = DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE); - if (CmdFailed(cost)) goto handle_nocash; - _companies_ai[c->index].wagon_list[i] = _new_vehicle_id; - _companies_ai[c->index].wagon_list[i + 1] = INVALID_VEHICLE; - return; - } - if (cargo == CT_MAIL) cargo = CT_PASSENGERS; - if (++i == _companies_ai[c->index].num_wagons * 2 - 1) break; - } - - // Which locomotive to build? - veh = AiChooseTrainToBuild(_companies_ai[c->index].railtype_to_use, c->money, cargo != CT_PASSENGERS ? 1 : 0, tile); - if (veh == INVALID_ENGINE) { -handle_nocash: - // after a while, if AI still doesn't have cash, get out of this block by selling the wagons. - if (++_companies_ai[c->index].state_counter == 1000) { - for (i = 0; _companies_ai[c->index].wagon_list[i] != INVALID_VEHICLE; i++) { - cost = DoCommand(tile, _companies_ai[c->index].wagon_list[i], 0, DC_EXEC, CMD_SELL_RAIL_WAGON); - assert(CmdSucceeded(cost)); - } - _companies_ai[c->index].state = AIS_0; - } - return; - } - - // Try to build the locomotive - cost = DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE); - assert(CmdSucceeded(cost)); - loco_id = _new_vehicle_id; - - // Sell a vehicle if the train is double headed. - v = GetVehicle(loco_id); - if (v->Next() != NULL) { - i = _companies_ai[c->index].wagon_list[_companies_ai[c->index].num_wagons * 2 - 2]; - _companies_ai[c->index].wagon_list[_companies_ai[c->index].num_wagons * 2 - 2] = INVALID_VEHICLE; - DoCommand(tile, i, 0, DC_EXEC, CMD_SELL_RAIL_WAGON); - } - - // Move the wagons onto the train - for (i = 0; _companies_ai[c->index].wagon_list[i] != INVALID_VEHICLE; i++) { - DoCommand(tile, _companies_ai[c->index].wagon_list[i] | (loco_id << 16), 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE); - } - - for (i = 0; _companies_ai[c->index].order_list_blocks[i] != 0xFF; i++) { - const AiBuildRec *aib = &_companies_ai[c->index].src + _companies_ai[c->index].order_list_blocks[i]; - bool is_pass = ( - _companies_ai[c->index].cargo_type == CT_PASSENGERS || - _companies_ai[c->index].cargo_type == CT_MAIL || - (_settings_game.game_creation.landscape == LT_TEMPERATE && _companies_ai[c->index].cargo_type == CT_VALUABLES) - ); - Order order; - - order.MakeGoToStation(AiGetStationIdByDef(aib->use_tile, aib->cur_building_rule)); - - if (!is_pass && i == 1) order.SetUnloadType(OUFB_UNLOAD); - if (_companies_ai[c->index].num_want_fullload != 0 && (is_pass || i == 0)) - order.SetLoadType(OLFB_FULL_LOAD); - - DoCommand(0, loco_id + (i << 16), order.Pack(), DC_EXEC, CMD_INSERT_ORDER); - } - - DoCommand(0, loco_id, 0, DC_EXEC, CMD_START_STOP_VEHICLE); - - DoCommand(0, loco_id, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT); - - if (_companies_ai[c->index].num_want_fullload != 0) _companies_ai[c->index].num_want_fullload--; - - if (--_companies_ai[c->index].num_loco_to_build != 0) { -// _companies_ai[c->index].loco_id = INVALID_VEHICLE; - _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE; - } else { - _companies_ai[c->index].state = AIS_0; - } -} - -static void AiStateDeleteRailBlocks(Company *c) -{ - const AiBuildRec *aib = &_companies_ai[c->index].src; - uint num = _companies_ai[c->index].num_build_rec; - - do { - const AiDefaultBlockData *b; - - if (aib->cur_building_rule == 255) continue; - for (b = _default_rail_track_data[aib->cur_building_rule]->data; b->mode != 4; b++) { - DoCommand(TILE_ADD(aib->use_tile, ToTileIndexDiff(b->tileoffs)), 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR); - } - } while (++aib, --num); - - _companies_ai[c->index].state = AIS_0; -} - -static bool AiCheckRoadResources(TileIndex tile, const AiDefaultBlockData *p, byte cargo) -{ - uint values[NUM_CARGO]; - int rad; - - if (_settings_game.station.modified_catchment) { - rad = CA_TRUCK; // Same as CA_BUS at the moment? - } else { // change that at some point? - rad = 4; - } - - for (;; p++) { - if (p->mode == 4) { - return true; - } else if (p->mode == 1) { - TileIndex tile2 = TILE_ADD(tile, ToTileIndexDiff(p->tileoffs)); - - if (cargo & 0x80) { - GetProductionAroundTiles(values, tile2, 1, 1, rad); - return values[cargo & 0x7F] != 0; - } else { - GetAcceptanceAroundTiles(values, tile2, 1, 1, rad); - return (values[cargo]&~7) != 0; - } - } - } -} - -static bool _want_road_truck_station; -static CommandCost AiDoBuildDefaultRoadBlock(TileIndex tile, const AiDefaultBlockData *p, uint32 flag); - -// Returns rule and cost -static int AiFindBestDefaultRoadBlock(TileIndex tile, byte direction, byte cargo, CommandCost *cost) -{ - int i; - const AiDefaultRoadBlock *p; - - _want_road_truck_station = (cargo & 0x7F) != CT_PASSENGERS; - - for (i = 0; (p = _road_default_block_data[i]) != NULL; i++) { - if (p->dir == direction) { - *cost = AiDoBuildDefaultRoadBlock(tile, p->data, 0); - if (CmdSucceeded(*cost) && AiCheckRoadResources(tile, p->data, cargo)) - return i; - } - } - - return -1; -} - -static CommandCost AiDoBuildDefaultRoadBlock(TileIndex tile, const AiDefaultBlockData *p, uint32 flag) -{ - CommandCost ret; - CommandCost total_cost(EXPENSES_CONSTRUCTION); - Town *t = NULL; - int rating = 0; - int roadflag = 0; - - for (;p->mode != 4;p++) { - TileIndex c = TILE_MASK(tile + ToTileIndexDiff(p->tileoffs)); - - _cleared_town = NULL; - - if (p->mode == 2) { - if (IsNormalRoadTile(c) && - (GetRoadBits(c, ROADTYPE_ROAD) & p->attr) != 0) { - roadflag |= 2; - - // all bits are already built? - if ((GetRoadBits(c, ROADTYPE_ROAD) & p->attr) == p->attr) continue; - } - - ret = DoCommand(c, p->attr, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD); - if (CmdFailed(ret)) return CMD_ERROR; - total_cost.AddCost(ret); - - continue; - } - - if (p->mode == 0) { - // Depot - ret = DoCommand(c, p->attr, 0, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_ROAD_DEPOT); - goto clear_town_stuff; - } else if (p->mode == 1) { - if (_want_road_truck_station) { - // Truck station - ret = DoCommand(c, p->attr, ROADTYPES_ROAD << 2 | ROADSTOP_TRUCK | INVALID_STATION << 16, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_ROAD_STOP); - } else { - // Bus station - ret = DoCommand(c, p->attr, ROADTYPES_ROAD << 2 | ROADSTOP_BUS | INVALID_STATION << 16, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_ROAD_STOP); - } -clear_town_stuff:; - - if (CmdFailed(ret)) return CMD_ERROR; - total_cost.AddCost(ret); - - if (_cleared_town != NULL) { - if (t != NULL && t != _cleared_town) return CMD_ERROR; - t = _cleared_town; - rating += _cleared_town_rating; - } - } else if (p->mode == 3) { - if (flag & DC_EXEC) continue; - - if (GetTileSlope(c, NULL) != SLOPE_FLAT) return CMD_ERROR; - - if (!IsNormalRoadTile(c)) { - ret = DoCommand(c, 0, 0, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_LANDSCAPE_CLEAR); - if (CmdFailed(ret)) return CMD_ERROR; - } - - } - } - - if (!_want_road_truck_station && !(roadflag & 2)) return CMD_ERROR; - - if (!(flag & DC_EXEC)) { - if (t != NULL && rating > t->ratings[_current_company]) return CMD_ERROR; - } - return total_cost; -} - -// Make sure the blocks are not too close to each other -static bool AiCheckBlockDistances(Company *c, TileIndex tile) -{ - const AiBuildRec *aib = &_companies_ai[c->index].src; - uint num = _companies_ai[c->index].num_build_rec; - - do { - if (aib->cur_building_rule != 255) { - if (DistanceManhattan(aib->use_tile, tile) < 9) return false; - } - } while (++aib, --num); - - return true; -} - - -static void AiStateBuildDefaultRoadBlocks(Company *c) -{ - uint i; - int j; - AiBuildRec *aib; - int rule; - CommandCost cost; - - // time out? - if (++_companies_ai[c->index].timeout_counter == 1388) { - _companies_ai[c->index].state = AIS_DELETE_RAIL_BLOCKS; - return; - } - - // do the following 8 times - for (i = 0; i != 8; i++) { - // check if we can build the default track - aib = &_companies_ai[c->index].src; - j = _companies_ai[c->index].num_build_rec; - do { - // this item has already been built? - if (aib->cur_building_rule != 255) continue; - - // adjust the coordinate randomly, - // to make sure that we find a position. - aib->use_tile = AdjustTileCoordRandomly(aib->spec_tile, aib->rand_rng); - - // check if the road can be built there. - rule = AiFindBestDefaultRoadBlock( - aib->use_tile, aib->direction, aib->cargo, &cost - ); - - if (rule == -1) { - // cannot build, terraform after a while - if (_companies_ai[c->index].state_counter >= 600) { - AiDoTerraformLand(aib->use_tile, (DiagDirection)(Random() & 3), 3, (int8)_companies_ai[c->index].state_mode); - } - // also try the other terraform direction - if (++_companies_ai[c->index].state_counter >= 1000) { - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].state_mode = -_companies_ai[c->index].state_mode; - } - } else if (CheckCompanyHasMoney(cost) && AiCheckBlockDistances(c, aib->use_tile)) { - CommandCost r; - - // company has money, build it. - aib->cur_building_rule = rule; - - r = AiDoBuildDefaultRoadBlock( - aib->use_tile, - _road_default_block_data[rule]->data, - DC_EXEC | DC_NO_TOWN_RATING - ); - assert(CmdSucceeded(r)); - } - } while (++aib, --j); - } - - // check if we're done with all of them - aib = &_companies_ai[c->index].src; - j = _companies_ai[c->index].num_build_rec; - do { - if (aib->cur_building_rule == 255) return; - } while (++aib, --j); - - // yep, all are done. switch state to the rail building state. - _companies_ai[c->index].state = AIS_BUILD_ROAD; - _companies_ai[c->index].state_mode = 255; -} - -struct AiRoadFinder { - TileIndex final_tile; - DiagDirection final_dir; - byte depth; - byte recursive_mode; - DiagDirection cur_best_dir; - DiagDirection best_dir; - byte cur_best_depth; - byte best_depth; - uint cur_best_dist; - const byte *best_ptr; - uint best_dist; - TileIndex cur_best_tile, best_tile; - TileIndex bridge_end_tile; - Company *company; -}; - -struct AiRoadEnum { - TileIndex dest; - TileIndex best_tile; - Trackdir best_track; - uint best_dist; -}; - -static void AiBuildRoadRecursive(AiRoadFinder *arf, TileIndex tile, DiagDirection dir); - -static bool AiCheckRoadPathBetter(AiRoadFinder *arf, const byte *p) -{ - bool better = false; - - if (arf->recursive_mode < 1) { - // Mode is 0. This means destination has not been found yet. - // If the found path is shorter than the current one, remember it. - if (arf->cur_best_dist < arf->best_dist || - (arf->cur_best_dist == arf->best_dist && arf->cur_best_depth < arf->best_depth)) { - arf->best_depth = arf->cur_best_depth; - arf->best_dist = arf->cur_best_dist; - arf->best_dir = arf->cur_best_dir; - arf->best_ptr = p; - arf->best_tile = arf->cur_best_tile; - better = true; - } - } else if (arf->recursive_mode > 1) { - // Mode is 2. - if (arf->best_dist != 0 || arf->cur_best_depth < arf->best_depth) { - arf->best_depth = arf->cur_best_depth; - arf->best_dist = 0; - arf->best_ptr = p; - arf->best_tile = 0; - better = true; - } - } - arf->recursive_mode = 0; - arf->cur_best_dist = UINT_MAX; - arf->cur_best_depth = 0xff; - - return better; -} - - -static bool AiEnumFollowRoad(TileIndex tile, AiRoadEnum *a, Trackdir track, uint length) -{ - uint dist = DistanceManhattan(tile, a->dest); - - if (dist <= a->best_dist) { - TileIndex tile2 = TILE_MASK(tile + TileOffsByDiagDir(TrackdirToExitdir(track))); - - if (IsNormalRoadTile(tile2)) { - a->best_dist = dist; - a->best_tile = tile; - a->best_track = track; - } - } - - return false; -} - -static bool AiCheckRoadFinished(Company *c) -{ - AiRoadEnum are; - TileIndex tile; - DiagDirection dir = _companies_ai[c->index].cur_dir_a; - - are.dest = _companies_ai[c->index].cur_tile_b; - tile = TILE_MASK(_companies_ai[c->index].cur_tile_a + TileOffsByDiagDir(dir)); - - if (IsRoadStopTile(tile) || IsRoadDepotTile(tile)) return false; - TrackdirBits bits = TrackStatusToTrackdirBits(GetTileTrackStatus(tile, TRANSPORT_ROAD, ROADTYPES_ROAD)) & DiagdirReachesTrackdirs(dir); - if (bits == TRACKDIR_BIT_NONE) return false; - - are.best_dist = UINT_MAX; - - while (bits != TRACKDIR_BIT_NONE) { - Trackdir trackdir = RemoveFirstTrackdir(&bits); - FollowTrack(tile, PATHFIND_FLAGS_DISABLE_TILE_HASH, TRANSPORT_ROAD, ROADTYPES_ROAD, TrackdirToExitdir(trackdir), (TPFEnumProc*)AiEnumFollowRoad, NULL, &are); - } - - if (DistanceManhattan(tile, are.dest) <= are.best_dist) return false; - - if (are.best_dist == 0) return true; - - _companies_ai[c->index].cur_tile_a = are.best_tile; - _companies_ai[c->index].cur_dir_a = TrackdirToExitdir(are.best_track); - return false; -} - - -static bool AiBuildRoadHelper(TileIndex tile, uint32 flags, int type) -{ - static const RoadBits _road_bits[] = { - ROAD_X, - ROAD_Y, - ROAD_NW | ROAD_NE, - ROAD_SW | ROAD_SE, - ROAD_NW | ROAD_SW, - ROAD_SE | ROAD_NE - }; - return CmdSucceeded(DoCommand(tile, _road_bits[type], 0, flags, CMD_BUILD_ROAD)); -} - -static inline void AiCheckBuildRoadBridgeHere(AiRoadFinder *arf, TileIndex tile, const byte *p) -{ - Slope tileh; - uint z; - bool flag; - - DiagDirection dir2 = (DiagDirection)(p[0] & 3); - - tileh = GetTileSlope(tile, &z); - if (tileh == InclinedSlope(ReverseDiagDir(dir2)) || (tileh == SLOPE_FLAT && z != 0)) { - TileIndex tile_new = tile; - - // Allow bridges directly over bottom tiles - flag = z == 0; - for (;;) { - TileType type; - - if ((TileIndexDiff)tile_new < -TileOffsByDiagDir(dir2)) return; // Wraping around map, no bridge possible! - tile_new = TILE_MASK(tile_new + TileOffsByDiagDir(dir2)); - type = GetTileType(tile_new); - - if (type == MP_CLEAR || type == MP_TREES || GetTileSlope(tile_new, NULL) != SLOPE_FLAT) { - // Allow a bridge if either we have a tile that's water, rail or street, - // or if we found an up tile. - if (!flag) return; - break; - } - if (type != MP_WATER && type != MP_RAILWAY && type != MP_ROAD) return; - flag = true; - } - - // Is building a (rail)bridge possible at this place (type doesn't matter)? - if (CmdFailed(DoCommand(tile_new, tile, ROADTYPES_ROAD << 8 | TRANSPORT_ROAD << 15, DC_AUTO, CMD_BUILD_BRIDGE))) - return; - AiBuildRoadRecursive(arf, tile_new, dir2); - - // At the bottom depth, check if the new path is better than the old one. - if (arf->depth == 1) { - if (AiCheckRoadPathBetter(arf, p)) arf->bridge_end_tile = tile_new; - } - } -} - -static inline void AiCheckBuildRoadTunnelHere(AiRoadFinder *arf, TileIndex tile, const byte *p) -{ - uint z; - - if (GetTileSlope(tile, &z) == InclinedSlope((DiagDirection)(p[0] & 3)) && z != 0) { - CommandCost cost = DoCommand(tile, 0x200, 0, DC_AUTO, CMD_BUILD_TUNNEL); - - if (CmdSucceeded(cost) && cost.GetCost() <= (arf->company->money >> 4)) { - AiBuildRoadRecursive(arf, _build_tunnel_endtile, (DiagDirection)(p[0] & 3)); - if (arf->depth == 1) AiCheckRoadPathBetter(arf, p); - } - } -} - - - -static void AiBuildRoadRecursive(AiRoadFinder *arf, TileIndex tile, DiagDirection dir) -{ - const byte *p; - - tile = TILE_MASK(tile + TileOffsByDiagDir(dir)); - - // Reached destination? - if (tile == arf->final_tile) { - if (ReverseDiagDir(arf->final_dir) == dir) { - arf->recursive_mode = 2; - arf->cur_best_depth = arf->depth; - } - return; - } - - // Depth too deep? - if (arf->depth >= 4) { - uint dist = DistanceMaxPlusManhattan(tile, arf->final_tile); - if (dist < arf->cur_best_dist) { - // Store the tile that is closest to the final position. - arf->cur_best_dist = dist; - arf->cur_best_tile = tile; - arf->cur_best_dir = dir; - arf->cur_best_depth = arf->depth; - } - return; - } - - // Increase recursion depth - arf->depth++; - - // Grab pointer to list of stuff that is possible to build - p = _ai_table_15[dir]; - - // Try to build a single rail in all directions. - if (GetTileZ(tile) == 0) { - p += 6; - } else { - do { - // Make sure that a road can be built here. - if (AiBuildRoadHelper(tile, DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, p[0])) { - AiBuildRoadRecursive(arf, tile, (DiagDirection)p[1]); - } - - // At the bottom depth? - if (arf->depth == 1) AiCheckRoadPathBetter(arf, p); - - p += 2; - } while (!(p[0] & 0x80)); - } - - AiCheckBuildRoadBridgeHere(arf, tile, p); - AiCheckBuildRoadTunnelHere(arf, tile, p + 1); - - arf->depth--; -} - - -static void AiBuildRoadConstruct(Company *c) -{ - AiRoadFinder arf; - int i; - TileIndex tile; - - // Reached destination? - if (AiCheckRoadFinished(c)) { - _companies_ai[c->index].state_mode = 255; - return; - } - - // Setup recursive finder and call it. - arf.company = c; - arf.final_tile = _companies_ai[c->index].cur_tile_b; - arf.final_dir = _companies_ai[c->index].cur_dir_b; - arf.depth = 0; - arf.recursive_mode = 0; - arf.best_ptr = NULL; - arf.cur_best_dist = UINT_MAX; - arf.cur_best_depth = 0xff; - arf.best_dist = UINT_MAX; - arf.best_depth = 0xff; - arf.cur_best_tile = 0; - arf.best_tile = 0; - AiBuildRoadRecursive(&arf, _companies_ai[c->index].cur_tile_a, _companies_ai[c->index].cur_dir_a); - - // Reached destination? - if (arf.recursive_mode == 2 && arf.cur_best_depth == 0) { - _companies_ai[c->index].state_mode = 255; - return; - } - - // Didn't find anything to build? - if (arf.best_ptr == NULL) { - // Terraform some -do_some_terraform: - for (i = 0; i != 5; i++) - AiDoTerraformLand(_companies_ai[c->index].cur_tile_a, _companies_ai[c->index].cur_dir_a, 3, 0); - - if (++_companies_ai[c->index].state_counter == 21) { - _companies_ai[c->index].state_mode = 1; - - _companies_ai[c->index].cur_tile_a = TILE_MASK(_companies_ai[c->index].cur_tile_a + TileOffsByDiagDir(_companies_ai[c->index].cur_dir_a)); - _companies_ai[c->index].cur_dir_a = ReverseDiagDir(_companies_ai[c->index].cur_dir_a); - _companies_ai[c->index].state_counter = 0; - } - return; - } - - tile = TILE_MASK(_companies_ai[c->index].cur_tile_a + TileOffsByDiagDir(_companies_ai[c->index].cur_dir_a)); - - if (arf.best_ptr[0] & 0x80) { - TileIndex t1 = tile; - TileIndex t2 = arf.bridge_end_tile; - - int32 bridge_len = GetTunnelBridgeLength(t1, t2); - - Axis axis = (TileX(t1) == TileX(t2) ? AXIS_Y : AXIS_X); - - /* try to build a long road instead of bridge - CMD_BUILD_LONG_ROAD has to fail if it couldn't build at least one piece! */ - CommandCost cost = DoCommand(t2, t1, (t2 < t1 ? 1 : 2) | (axis << 2) | (ROADTYPE_ROAD << 3), DC_AUTO | DC_NO_WATER, CMD_BUILD_LONG_ROAD); - - if (CmdSucceeded(cost) && cost.GetCost() <= c->money) { - DoCommand(t2, t1, (t2 < t1 ? 1 : 2) | (axis << 2) | (ROADTYPE_ROAD << 3), DC_AUTO | DC_EXEC | DC_NO_WATER, CMD_BUILD_LONG_ROAD); - } else { - int i; - - /* Figure out what (road)bridge type to build - * start with best bridge, then go down to worse and worse bridges - * unnecessary to check for worse bridge (i=0), since AI will always build that */ - for (i = MAX_BRIDGES - 1; i != 0; i--) { - if (CheckBridge_Stuff(i, bridge_len)) { - CommandCost cost = DoCommand(t1, t2, i | ROADTYPES_ROAD << 8 | TRANSPORT_ROAD << 15, DC_AUTO, CMD_BUILD_BRIDGE); - if (CmdSucceeded(cost) && cost.GetCost() < (c->money >> 1) && cost.GetCost() < ((c->money + _economy.max_loan - c->current_loan) >> 5)) break; - } - } - - /* Build it */ - DoCommand(t1, t2, i | ROADTYPES_ROAD << 8 | TRANSPORT_ROAD << 15, DC_AUTO | DC_EXEC, CMD_BUILD_BRIDGE); - } - - _companies_ai[c->index].cur_tile_a = t2; - _companies_ai[c->index].state_counter = 0; - } else if (arf.best_ptr[0] & 0x40) { - // tunnel - DoCommand(tile, 0x200, 0, DC_AUTO | DC_EXEC, CMD_BUILD_TUNNEL); - _companies_ai[c->index].cur_tile_a = _build_tunnel_endtile; - _companies_ai[c->index].state_counter = 0; - } else { - // road - if (!AiBuildRoadHelper(tile, DC_EXEC | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, arf.best_ptr[0])) - goto do_some_terraform; - - _companies_ai[c->index].cur_dir_a = (DiagDirection)(arf.best_ptr[1] & 3); - _companies_ai[c->index].cur_tile_a = tile; - _companies_ai[c->index].state_counter = 0; - } - - if (arf.best_tile != 0) { - for (i = 0; i != 2; i++) - AiDoTerraformLand(arf.best_tile, arf.best_dir, 3, 0); - } -} - - -static void AiBuildRoad(Company *c) -{ - if (_companies_ai[c->index].state_mode < 1) { - // Construct mode, build new road. - AiBuildRoadConstruct(c); - } else if (_companies_ai[c->index].state_mode == 1) { - // Destruct mode, not implemented for roads. - _companies_ai[c->index].state_mode = 2; - _companies_ai[c->index].state_counter = 0; - } else if (_companies_ai[c->index].state_mode == 2) { - uint i; - - // Terraform some and then try building again. - for (i = 0; i != 4; i++) { - AiDoTerraformLand(_companies_ai[c->index].cur_tile_a, _companies_ai[c->index].cur_dir_a, 3, 0); - } - - if (++_companies_ai[c->index].state_counter == 4) { - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].state_mode = 0; - } - } -} - -static TileIndex AiGetRoadBlockEdge(byte rule, TileIndex tile, DiagDirection *dir) -{ - const AiDefaultBlockData *p = _road_default_block_data[rule]->data; - while (p->mode != 1) p++; - *dir = p->attr; - return TILE_ADD(tile, ToTileIndexDiff(p->tileoffs)); -} - - -static void AiStateBuildRoad(Company *c) -{ - int num; - AiBuildRec *aib; - byte cmd; - TileIndex tile; - DiagDirection dir; - - // time out? - if (++_companies_ai[c->index].timeout_counter == 1388) { - _companies_ai[c->index].state = AIS_DELETE_ROAD_BLOCKS; - return; - } - - // Currently building a road between two points? - if (_companies_ai[c->index].state_mode != 255) { - AiBuildRoad(c); - - // Alternate between edges - Swap(_companies_ai[c->index].start_tile_a, _companies_ai[c->index].start_tile_b); - Swap(_companies_ai[c->index].cur_tile_a, _companies_ai[c->index].cur_tile_b); - Swap(_companies_ai[c->index].start_dir_a, _companies_ai[c->index].start_dir_b); - Swap(_companies_ai[c->index].cur_dir_a, _companies_ai[c->index].cur_dir_b); - - return; - } - - // Now, find two new points to build between - num = _companies_ai[c->index].num_build_rec; - aib = &_companies_ai[c->index].src; - - for (;;) { - cmd = aib->buildcmd_a; - aib->buildcmd_a = 255; - if (cmd != 255) break; - - aib++; - if (--num == 0) { - _companies_ai[c->index].state = AIS_BUILD_ROAD_VEHICLES; - return; - } - } - - // Find first edge to build from. - tile = AiGetRoadBlockEdge(aib->cur_building_rule, aib->use_tile, &dir); - _companies_ai[c->index].start_tile_a = tile; - _companies_ai[c->index].cur_tile_a = tile; - _companies_ai[c->index].start_dir_a = dir; - _companies_ai[c->index].cur_dir_a = dir; - - // Find second edge to build to - aib = (&_companies_ai[c->index].src) + (cmd & 0xF); - tile = AiGetRoadBlockEdge(aib->cur_building_rule, aib->use_tile, &dir); - _companies_ai[c->index].start_tile_b = tile; - _companies_ai[c->index].cur_tile_b = tile; - _companies_ai[c->index].start_dir_b = dir; - _companies_ai[c->index].cur_dir_b = dir; - - // And setup state. - _companies_ai[c->index].state_mode = 2; - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].banned_tile_count = 0; -} - -static StationID AiGetStationIdFromRoadBlock(TileIndex tile, int id) -{ - const AiDefaultBlockData *p = _road_default_block_data[id]->data; - while (p->mode != 1) p++; - return GetStationIndex(TILE_ADD(tile, ToTileIndexDiff(p->tileoffs))); -} - -static void AiStateBuildRoadVehicles(Company *c) -{ - const AiDefaultBlockData *ptr; - TileIndex tile; - VehicleID loco_id; - EngineID veh; - uint i; - - ptr = _road_default_block_data[_companies_ai[c->index].src.cur_building_rule]->data; - for (; ptr->mode != 0; ptr++) {} - tile = TILE_ADD(_companies_ai[c->index].src.use_tile, ToTileIndexDiff(ptr->tileoffs)); - - veh = AiChooseRoadVehToBuild(_companies_ai[c->index].cargo_type, c->money, tile); - if (veh == INVALID_ENGINE) { - _companies_ai[c->index].state = AIS_0; - return; - } - - if (CmdFailed(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH))) return; - - loco_id = _new_vehicle_id; - - if (GetVehicle(loco_id)->cargo_type != _companies_ai[c->index].cargo_type) { - /* Cargo type doesn't match, so refit it */ - if (CmdFailed(DoCommand(tile, loco_id, _companies_ai[c->index].cargo_type, DC_EXEC, CMD_REFIT_ROAD_VEH))) { - /* Refit failed... sell the vehicle */ - DoCommand(tile, loco_id, 0, DC_EXEC, CMD_SELL_ROAD_VEH); - return; - } - } - - for (i = 0; _companies_ai[c->index].order_list_blocks[i] != 0xFF; i++) { - const AiBuildRec *aib = &_companies_ai[c->index].src + _companies_ai[c->index].order_list_blocks[i]; - bool is_pass = ( - _companies_ai[c->index].cargo_type == CT_PASSENGERS || - _companies_ai[c->index].cargo_type == CT_MAIL || - (_settings_game.game_creation.landscape == LT_TEMPERATE && _companies_ai[c->index].cargo_type == CT_VALUABLES) - ); - Order order; - - order.MakeGoToStation(AiGetStationIdFromRoadBlock(aib->use_tile, aib->cur_building_rule)); - - if (!is_pass && i == 1) order.SetUnloadType(OUFB_UNLOAD); - if (_companies_ai[c->index].num_want_fullload != 0 && (is_pass || i == 0)) - order.SetLoadType(OLFB_FULL_LOAD); - - DoCommand(0, loco_id + (i << 16), order.Pack(), DC_EXEC, CMD_INSERT_ORDER); - } - - DoCommand(0, loco_id, 0, DC_EXEC, CMD_START_STOP_VEHICLE); - DoCommand(0, loco_id, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT); - - if (_companies_ai[c->index].num_want_fullload != 0) _companies_ai[c->index].num_want_fullload--; - if (--_companies_ai[c->index].num_loco_to_build == 0) _companies_ai[c->index].state = AIS_0; -} - -static void AiStateDeleteRoadBlocks(Company *c) -{ - const AiBuildRec *aib = &_companies_ai[c->index].src; - uint num = _companies_ai[c->index].num_build_rec; - - do { - const AiDefaultBlockData *b; - - if (aib->cur_building_rule == 255) continue; - for (b = _road_default_block_data[aib->cur_building_rule]->data; b->mode != 4; b++) { - if (b->mode > 1) continue; - DoCommand(TILE_ADD(aib->use_tile, ToTileIndexDiff(b->tileoffs)), 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR); - } - } while (++aib, --num); - - _companies_ai[c->index].state = AIS_0; -} - - -static void AiStateAirportStuff(Company *c) -{ - const Station *st; - int i; - AiBuildRec *aib; - byte rule; - - // Here we look for an airport we could use instead of building a new - // one. If we find such an aiport for any waypoint, - // AiStateBuildDefaultAirportBlocks() will kindly skip that one when - // building the waypoints. - - i = 0; - do { - // We do this all twice - once for the source (town in the case - // of oilrig route) and then for the destination (oilrig in the - // case of oilrig route). - aib = &_companies_ai[c->index].src + i; - - FOR_ALL_STATIONS(st) { - // Is this an airport? - if (!(st->facilities & FACIL_AIRPORT)) continue; - - // Do we own the airport? (Oilrigs aren't owned, though.) - if (st->owner != OWNER_NONE && st->owner != _current_company) continue; - - AirportFTAClass::Flags flags = st->Airport()->flags; - - /* if airport doesn't accept our kind of plane, dismiss it */ - if (!(flags & (_companies_ai[c->index].build_kind == 1 ? AirportFTAClass::HELICOPTERS : AirportFTAClass::AIRPLANES))) { - continue; - } - - // Dismiss airports too far away. - if (DistanceMax(st->airport_tile, aib->spec_tile) > aib->rand_rng) - continue; - - // It's ideal airport, let's take it! - - /* XXX: This part is utterly broken - rule should - * contain number of the rule appropriate for the - * airport type (country, town, ...), see - * _airport_default_block_data (rule is just an index - * in this array). But the only difference between the - * currently existing two rules (rule 0 - town and rule - * 1 - country) is the attr field which is used only - * when building new airports - and that's irrelevant - * for us. So using just about any rule will suffice - * here for now (some of the new airport types would be - * broken because they will probably need different - * tileoff values etc), no matter that - * IsHangarTile() makes no sense. --pasky */ - if (!(flags & AirportFTAClass::AIRPLANES)) { - /* Heliports should have maybe own rulesets but - * OTOH we don't want AI to pick them up when - * looking for a suitable airport type to build. - * So any of rules 0 or 1 would do for now. The - * original rule number was 2 but that's a bug - * because we have no such rule. */ - rule = 1; - } else { - rule = IsHangarTile(st->airport_tile); - } - - aib->cur_building_rule = rule; - aib->use_tile = st->airport_tile; - break; - } - } while (++i != _companies_ai[c->index].num_build_rec); - - _companies_ai[c->index].state = AIS_BUILD_DEFAULT_AIRPORT_BLOCKS; - _companies_ai[c->index].state_mode = 255; - _companies_ai[c->index].state_counter = 0; -} - -static CommandCost AiDoBuildDefaultAirportBlock(TileIndex tile, const AiDefaultBlockData *p, uint32 flag) -{ - uint32 avail_airports = GetValidAirports(); - CommandCost ret, total_cost(EXPENSES_CONSTRUCTION); - - for (; p->mode == 0; p++) { - if (!HasBit(avail_airports, p->attr)) return CMD_ERROR; - ret = DoCommand(TILE_MASK(tile + ToTileIndexDiff(p->tileoffs)), p->attr, INVALID_STATION << 16, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_AIRPORT); - if (CmdFailed(ret)) return CMD_ERROR; - total_cost.AddCost(ret); - } - - return total_cost; -} - -static bool AiCheckAirportResources(TileIndex tile, const AiDefaultBlockData *p, byte cargo) -{ - uint values[NUM_CARGO]; - - for (; p->mode == 0; p++) { - TileIndex tile2 = TILE_ADD(tile, ToTileIndexDiff(p->tileoffs)); - const AirportFTAClass *airport = GetAirport(p->attr); - uint w = airport->size_x; - uint h = airport->size_y; - uint rad = _settings_game.station.modified_catchment ? airport->catchment : (uint)CA_UNMODIFIED; - - if (cargo & 0x80) { - GetProductionAroundTiles(values, tile2, w, h, rad); - return values[cargo & 0x7F] != 0; - } else { - GetAcceptanceAroundTiles(values, tile2, w, h, rad); - return values[cargo] >= 8; - } - } - return true; -} - -static int AiFindBestDefaultAirportBlock(TileIndex tile, byte cargo, byte heli, CommandCost *cost) -{ - const AiDefaultBlockData *p; - - bool no_small = false; - - if (!heli) { - /* do not build small airport if we have large available and we are not building heli route */ - uint valid = GetValidAirports(); - for (uint i = 0; (p = _airport_default_block_data[i]) != NULL; i++) { - uint flags = GetAirport(p->attr)->flags; - if (HasBit(valid, p->attr) && (flags & AirportFTAClass::AIRPLANES) && !(flags & AirportFTAClass::SHORT_STRIP)) { - no_small = true; - break; - } - } - } - - for (uint i = 0; (p = _airport_default_block_data[i]) != NULL; i++) { - uint flags = GetAirport(p->attr)->flags; - /* If we are doing a helicopter service, avoid building airports where they can't land */ - if (heli && !(flags & AirportFTAClass::HELICOPTERS)) continue; - /* Similiar with aircraft ... */ - if (!heli && !(flags & AirportFTAClass::AIRPLANES)) continue; - /* Do not build small airport if we prefer large */ - if (no_small && (flags & AirportFTAClass::SHORT_STRIP)) continue; - - *cost = AiDoBuildDefaultAirportBlock(tile, p, 0); - if (CmdSucceeded(*cost) && AiCheckAirportResources(tile, p, cargo)) - return i; - } - return -1; -} - -static void AiStateBuildDefaultAirportBlocks(Company *c) -{ - int i, j; - AiBuildRec *aib; - int rule; - CommandCost cost; - - // time out? - if (++_companies_ai[c->index].timeout_counter == 1388) { - _companies_ai[c->index].state = AIS_0; - return; - } - - // do the following 8 times - i = 8; - do { - // check if we can build the default - aib = &_companies_ai[c->index].src; - j = _companies_ai[c->index].num_build_rec; - do { - // this item has already been built? - if (aib->cur_building_rule != 255) continue; - - // adjust the coordinate randomly, - // to make sure that we find a position. - aib->use_tile = AdjustTileCoordRandomly(aib->spec_tile, aib->rand_rng); - - // check if the aircraft stuff can be built there. - rule = AiFindBestDefaultAirportBlock(aib->use_tile, aib->cargo, _companies_ai[c->index].build_kind, &cost); - -// SetRedErrorSquare(aib->use_tile); - - if (rule == -1) { - // cannot build, terraform after a while - if (_companies_ai[c->index].state_counter >= 600) { - AiDoTerraformLand(aib->use_tile, (DiagDirection)(Random() & 3), 3, (int8)_companies_ai[c->index].state_mode); - } - // also try the other terraform direction - if (++_companies_ai[c->index].state_counter >= 1000) { - _companies_ai[c->index].state_counter = 0; - _companies_ai[c->index].state_mode = -_companies_ai[c->index].state_mode; - } - } else if (CheckCompanyHasMoney(cost) && AiCheckBlockDistances(c, aib->use_tile)) { - // company has money, build it. - CommandCost r; - - aib->cur_building_rule = rule; - - r = AiDoBuildDefaultAirportBlock( - aib->use_tile, - _airport_default_block_data[rule], - DC_EXEC | DC_NO_TOWN_RATING - ); - assert(CmdSucceeded(r)); - } - } while (++aib, --j); - } while (--i); - - // check if we're done with all of them - aib = &_companies_ai[c->index].src; - j = _companies_ai[c->index].num_build_rec; - do { - if (aib->cur_building_rule == 255) return; - } while (++aib, --j); - - // yep, all are done. switch state. - _companies_ai[c->index].state = AIS_BUILD_AIRCRAFT_VEHICLES; -} - -static StationID AiGetStationIdFromAircraftBlock(TileIndex tile, int id) -{ - const AiDefaultBlockData *p = _airport_default_block_data[id]; - while (p->mode != 1) p++; - return GetStationIndex(TILE_ADD(tile, ToTileIndexDiff(p->tileoffs))); -} - -static void AiStateBuildAircraftVehicles(Company *c) -{ - const AiDefaultBlockData *ptr; - TileIndex tile; - EngineID veh; - int i; - VehicleID loco_id; - - ptr = _airport_default_block_data[_companies_ai[c->index].src.cur_building_rule]; - for (; ptr->mode != 0; ptr++) {} - - tile = TILE_ADD(_companies_ai[c->index].src.use_tile, ToTileIndexDiff(ptr->tileoffs)); - - /* determine forbidden aircraft bits */ - byte forbidden = 0; - for (i = 0; _companies_ai[c->index].order_list_blocks[i] != 0xFF; i++) { - const AiBuildRec *aib = (&_companies_ai[c->index].src) + _companies_ai[c->index].order_list_blocks[i]; - const Station *st = GetStationByTile(aib->use_tile); - - if (st == NULL || !(st->facilities & FACIL_AIRPORT)) continue; - - AirportFTAClass::Flags flags = st->Airport()->flags; - if (!(flags & AirportFTAClass::AIRPLANES)) forbidden |= AIR_CTOL | AIR_FAST; // no planes for heliports / oil rigs - if (flags & AirportFTAClass::SHORT_STRIP) forbidden |= AIR_FAST; // no fast planes for small airports - } - - veh = AiChooseAircraftToBuild(c->money, forbidden); - if (veh == INVALID_ENGINE) return; - if (GetStationByTile(tile)->Airport()->nof_depots == 0) return; - - /* XXX - Have the AI pick the hangar terminal in an airport. Eg get airport-type - * and offset to the FIRST depot because the AI picks the st->xy tile */ - tile += ToTileIndexDiff(GetStationByTile(tile)->Airport()->airport_depots[0]); - if (CmdFailed(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT))) return; - loco_id = _new_vehicle_id; - - for (i = 0; _companies_ai[c->index].order_list_blocks[i] != 0xFF; i++) { - AiBuildRec *aib = (&_companies_ai[c->index].src) + _companies_ai[c->index].order_list_blocks[i]; - bool is_pass = (_companies_ai[c->index].cargo_type == CT_PASSENGERS || _companies_ai[c->index].cargo_type == CT_MAIL); - Order order; - - order.MakeGoToStation(AiGetStationIdFromAircraftBlock(aib->use_tile, aib->cur_building_rule)); - - if (!is_pass && i == 1) order.SetUnloadType(OUFB_UNLOAD); - if (_companies_ai[c->index].num_want_fullload != 0 && (is_pass || i == 0)) - order.SetLoadType(OLFB_FULL_LOAD); - - DoCommand(0, loco_id + (i << 16), order.Pack(), DC_EXEC, CMD_INSERT_ORDER); - } - - DoCommand(0, loco_id, 0, DC_EXEC, CMD_START_STOP_VEHICLE); - - DoCommand(0, loco_id, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT); - - if (_companies_ai[c->index].num_want_fullload != 0) _companies_ai[c->index].num_want_fullload--; - - if (--_companies_ai[c->index].num_loco_to_build == 0) _companies_ai[c->index].state = AIS_0; -} - -static void AiStateCheckShipStuff(Company *c) -{ - /* Ships are not implemented in this (broken) AI */ -} - -static void AiStateBuildDefaultShipBlocks(Company *c) -{ - /* Ships are not implemented in this (broken) AI */ -} - -static void AiStateDoShipStuff(Company *c) -{ - /* Ships are not implemented in this (broken) AI */ -} - -static void AiStateSellVeh(Company *c) -{ - Vehicle *v = _companies_ai[c->index].cur_veh; - - if (v->owner == _current_company) { - if (v->type == VEH_TRAIN) { - - if (!IsRailDepotTile(v->tile) || v->u.rail.track != TRACK_BIT_DEPOT || !(v->vehstatus & VS_STOPPED)) { - if (!v->current_order.IsType(OT_GOTO_DEPOT)) - DoCommand(0, v->index, 0, DC_EXEC, CMD_SEND_TRAIN_TO_DEPOT); - goto going_to_depot; - } - - // Sell whole train - DoCommand(v->tile, v->index, 1, DC_EXEC, CMD_SELL_RAIL_WAGON); - - } else if (v->type == VEH_ROAD) { - if (!v->IsStoppedInDepot()) { - if (!v->current_order.IsType(OT_GOTO_DEPOT)) - DoCommand(0, v->index, 0, DC_EXEC, CMD_SEND_ROADVEH_TO_DEPOT); - goto going_to_depot; - } - - DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH); - } else if (v->type == VEH_AIRCRAFT) { - if (!v->IsStoppedInDepot()) { - if (!v->current_order.IsType(OT_GOTO_DEPOT)) - DoCommand(0, v->index, 0, DC_EXEC, CMD_SEND_AIRCRAFT_TO_HANGAR); - goto going_to_depot; - } - - DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT); - } else if (v->type == VEH_SHIP) { - /* Ships are not implemented in this (broken) AI */ - } - } - - goto return_to_loop; -going_to_depot:; - if (++_companies_ai[c->index].state_counter <= 832) return; - - if (v->current_order.IsType(OT_GOTO_DEPOT)) { - v->current_order.MakeDummy(); - InvalidateWindow(WC_VEHICLE_VIEW, v->index); - } -return_to_loop:; - _companies_ai[c->index].state = AIS_VEH_LOOP; -} - -static void AiStateRemoveStation(Company *c) -{ - // Remove stations that aren't in use by any vehicle - const Order *ord; - const Station *st; - TileIndex tile; - - // Go to this state when we're done. - _companies_ai[c->index].state = AIS_1; - - // Get a list of all stations that are in use by a vehicle - byte *in_use = MallocT<byte>(GetMaxStationIndex() + 1); - memset(in_use, 0, GetMaxStationIndex() + 1); - FOR_ALL_ORDERS(ord) { - if (ord->IsType(OT_GOTO_STATION)) in_use[ord->GetDestination()] = 1; - } - - // Go through all stations and delete those that aren't in use - FOR_ALL_STATIONS(st) { - if (st->owner == _current_company && !in_use[st->index] && - ( (st->bus_stops != NULL && (tile = st->bus_stops->xy) != INVALID_TILE) || - (st->truck_stops != NULL && (tile = st->truck_stops->xy) != INVALID_TILE) || - (tile = st->train_tile) != INVALID_TILE || - (tile = st->dock_tile) != INVALID_TILE || - (tile = st->airport_tile) != INVALID_TILE)) { - DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR); - } - } - - free(in_use); -} - -static void AiRemoveCompanyRailOrRoad(Company *c, TileIndex tile) -{ - TrackBits rails; - - if (IsTileType(tile, MP_RAILWAY)) { - if (!IsTileOwner(tile, _current_company)) return; - - if (IsPlainRailTile(tile)) { -is_rail_crossing:; - rails = GetRailTrackStatus(tile); - - if (rails == TRACK_BIT_HORZ || rails == TRACK_BIT_VERT) return; - - if (rails & TRACK_BIT_3WAY_NE) { -pos_0: - if ((GetRailTrackStatus(TILE_MASK(tile - TileDiffXY(1, 0))) & TRACK_BIT_3WAY_SW) == 0) { - _companies_ai[c->index].cur_dir_a = DIAGDIR_NE; - _companies_ai[c->index].cur_tile_a = tile; - _companies_ai[c->index].state = AIS_REMOVE_SINGLE_RAIL_TILE; - return; - } - } - - if (rails & TRACK_BIT_3WAY_SE) { -pos_1: - if ((GetRailTrackStatus(TILE_MASK(tile + TileDiffXY(0, 1))) & TRACK_BIT_3WAY_NW) == 0) { - _companies_ai[c->index].cur_dir_a = DIAGDIR_SE; - _companies_ai[c->index].cur_tile_a = tile; - _companies_ai[c->index].state = AIS_REMOVE_SINGLE_RAIL_TILE; - return; - } - } - - if (rails & TRACK_BIT_3WAY_SW) { -pos_2: - if ((GetRailTrackStatus(TILE_MASK(tile + TileDiffXY(1, 0))) & TRACK_BIT_3WAY_NE) == 0) { - _companies_ai[c->index].cur_dir_a = DIAGDIR_SW; - _companies_ai[c->index].cur_tile_a = tile; - _companies_ai[c->index].state = AIS_REMOVE_SINGLE_RAIL_TILE; - return; - } - } - - if (rails & TRACK_BIT_3WAY_NW) { -pos_3: - if ((GetRailTrackStatus(TILE_MASK(tile - TileDiffXY(0, 1))) & TRACK_BIT_3WAY_SE) == 0) { - _companies_ai[c->index].cur_dir_a = DIAGDIR_NW; - _companies_ai[c->index].cur_tile_a = tile; - _companies_ai[c->index].state = AIS_REMOVE_SINGLE_RAIL_TILE; - return; - } - } - } else { - static const byte _depot_bits[] = {0x19, 0x16, 0x25, 0x2A}; - - DiagDirection dir = GetRailDepotDirection(tile); - - if (GetRailTrackStatus(tile + TileOffsByDiagDir(dir)) & _depot_bits[dir]) - return; - - DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR); - } - } else if (IsTileType(tile, MP_ROAD)) { - if (IsLevelCrossing(tile)) goto is_rail_crossing; - - if (IsRoadDepot(tile)) { - if (!IsTileOwner(tile, _current_company)) return; - - DiagDirection dir; - TileIndex t; - - // Check if there are any stations around. - t = tile + TileDiffXY(-1, 0); - if (IsTileType(t, MP_STATION) && IsTileOwner(t, _current_company)) return; - - t = tile + TileDiffXY(1, 0); - if (IsTileType(t, MP_STATION) && IsTileOwner(t, _current_company)) return; - - t = tile + TileDiffXY(0, -1); - if (IsTileType(t, MP_STATION) && IsTileOwner(t, _current_company)) return; - - t = tile + TileDiffXY(0, 1); - if (IsTileType(t, MP_STATION) && IsTileOwner(t, _current_company)) return; - - dir = GetRoadDepotDirection(tile); - - DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR); - DoCommand( - TILE_MASK(tile + TileOffsByDiagDir(dir)), - DiagDirToRoadBits(ReverseDiagDir(dir)), - 0, - DC_EXEC, - CMD_REMOVE_ROAD); - } - } else if (IsTileType(tile, MP_TUNNELBRIDGE)) { - if (!IsTileOwner(tile, _current_company) || - !IsBridge(tile) || - GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) { - return; - } - - rails = TRACK_BIT_NONE; - - switch (GetTunnelBridgeDirection(tile)) { - default: - case DIAGDIR_NE: goto pos_2; - case DIAGDIR_SE: goto pos_3; - case DIAGDIR_SW: goto pos_0; - case DIAGDIR_NW: goto pos_1; - } - } -} - -static void AiStateRemoveTrack(Company *c) -{ - /* Was 1000 for standard 8x8 maps. */ - int num = MapSizeX() * 4; - - do { - TileIndex tile = ++_companies_ai[c->index].state_counter; - - // Iterated all tiles? - if (tile >= MapSize()) { - _companies_ai[c->index].state = AIS_REMOVE_STATION; - return; - } - - // Remove company stuff in that tile - AiRemoveCompanyRailOrRoad(c, tile); - if (_companies_ai[c->index].state != AIS_REMOVE_TRACK) return; - } while (--num); -} - -static void AiStateRemoveSingleRailTile(Company *c) -{ - // Remove until we can't remove more. - if (!AiRemoveTileAndGoForward(c)) _companies_ai[c->index].state = AIS_REMOVE_TRACK; -} - -static AiStateAction * const _ai_actions[] = { - AiCase0, - AiCase1, - AiStateVehLoop, - AiStateCheckReplaceVehicle, - AiStateDoReplaceVehicle, - AiStateWantNewRoute, - - AiStateBuildDefaultRailBlocks, - AiStateBuildRail, - AiStateBuildRailVeh, - AiStateDeleteRailBlocks, - - AiStateBuildDefaultRoadBlocks, - AiStateBuildRoad, - AiStateBuildRoadVehicles, - AiStateDeleteRoadBlocks, - - AiStateAirportStuff, - AiStateBuildDefaultAirportBlocks, - AiStateBuildAircraftVehicles, - - AiStateCheckShipStuff, - AiStateBuildDefaultShipBlocks, - AiStateDoShipStuff, - - AiStateSellVeh, - AiStateRemoveStation, - AiStateRemoveTrack, - - AiStateRemoveSingleRailTile -}; - -extern void ShowBuyCompanyDialog(CompanyID company); - -static void AiHandleTakeover(Company *c) -{ - if (c->bankrupt_timeout != 0) { - c->bankrupt_timeout -= 8; - if (c->bankrupt_timeout > 0) return; - c->bankrupt_timeout = 0; - DeleteWindowById(WC_BUY_COMPANY, _current_company); - if (IsLocalCompany()) { - AskExitToGameMenu(); - return; - } - if (IsHumanCompany(_current_company)) return; - } - - if (c->bankrupt_asked == MAX_UVALUE(CompanyMask)) return; - - { - CompanyMask asked = c->bankrupt_asked; - Company *company, *best_company = NULL; - int32 best_val = -1; - - // Ask the guy with the highest performance hist. - FOR_ALL_COMPANIES(company) { - if (!(asked & 1) && - company->bankrupt_asked == 0 && - best_val < company->old_economy[1].performance_history) { - best_val = company->old_economy[1].performance_history; - best_company = company; - } - asked >>= 1; - } - - // Asked all companies? - if (best_val == -1) { - c->bankrupt_asked = MAX_UVALUE(CompanyMask); - return; - } - - SetBit(c->bankrupt_asked, best_company->index); - - if (best_company->index == _local_company) { - c->bankrupt_timeout = 4440; - ShowBuyCompanyDialog(_current_company); - return; - } - if (IsHumanCompany(best_company->index)) return; - - // Too little money for computer to buy it? - if (best_company->money >> 1 >= c->bankrupt_value) { - // Computer wants to buy it. - CompanyID old_company = _current_company; - _current_company = best_company->index; - DoCommand(0, old_company, 0, DC_EXEC, CMD_BUY_COMPANY); - _current_company = old_company; - } - } -} - -static void AiAdjustLoan(const Company *c) -{ - Money base = AiGetBasePrice(c); - - if (c->money > base * 1400) { - // Decrease loan - if (c->current_loan != 0) { - DoCommand(0, 0, 0, DC_EXEC, CMD_DECREASE_LOAN); - } - } else if (c->money < base * 500) { - // Increase loan - if (c->current_loan < _economy.max_loan && - c->num_valid_stat_ent >= 2 && - -(c->old_economy[0].expenses + c->old_economy[1].expenses) < base * 60) { - DoCommand(0, 0, 0, DC_EXEC, CMD_INCREASE_LOAN); - } - } -} - -static void AiBuildCompanyHQ(Company *c) -{ - TileIndex tile; - - if (c->location_of_HQ == INVALID_TILE && - c->last_build_coordinate != 0) { - tile = AdjustTileCoordRandomly(c->last_build_coordinate, 8); - DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ); - } -} - - -void AiDoGameLoop(Company *c) -{ - if (c->bankrupt_asked != 0) { - AiHandleTakeover(c); - return; - } - - // Ugly hack to make sure the service interval of the AI is good, not looking - // to the patch-setting - // Also, it takes into account the setting if the service-interval is in days - // or in % - _ai_service_interval = _settings_game.vehicle.servint_ispercent ? 80 : 180; - - if (IsHumanCompany(_current_company)) return; - - AiAdjustLoan(c); - AiBuildCompanyHQ(c); - -#if 0 - { - static byte old_state = 99; - static bool hasdots = false; - char *_ai_state_names[] = { - "AiCase0", - "AiCase1", - "AiStateVehLoop", - "AiStateCheckReplaceVehicle", - "AiStateDoReplaceVehicle", - "AiStateWantNewRoute", - "AiStateBuildDefaultRailBlocks", - "AiStateBuildRail", - "AiStateBuildRailVeh", - "AiStateDeleteRailBlocks", - "AiStateBuildDefaultRoadBlocks", - "AiStateBuildRoad", - "AiStateBuildRoadVehicles", - "AiStateDeleteRoadBlocks", - "AiStateAirportStuff", - "AiStateBuildDefaultAirportBlocks", - "AiStateBuildAircraftVehicles", - "AiStateCheckShipStuff", - "AiStateBuildDefaultShipBlocks", - "AiStateDoShipStuff", - "AiStateSellVeh", - "AiStateRemoveStation", - "AiStateRemoveTrack", - "AiStateRemoveSingleRailTile" - }; - - if (_companies_ai[c->index].state != old_state) { - if (hasdots) - printf("\n"); - hasdots = false; - printf("AiState: %s\n", _ai_state_names[old_state=_companies_ai[c->index].state]); - } else { - printf("."); - hasdots = true; - } - } -#endif - - _ai_actions[_companies_ai[c->index].state](c); -} diff --git a/src/ai/default/default.h b/src/ai/default/default.h deleted file mode 100644 index 843cf0f17..000000000 --- a/src/ai/default/default.h +++ /dev/null @@ -1,69 +0,0 @@ -/* $Id$ */ - -/** @file default.h The original AI. */ - -#ifndef DEFAULT_H -#define DEFAULT_H - -#include "../../direction_type.h" -#include "../../vehicle_type.h" -#include "../../rail_type.h" - -void AiDoGameLoop(Company *c); - -struct AiBuildRec { - TileIndex spec_tile; - TileIndex use_tile; - byte rand_rng; - byte cur_building_rule; - byte unk6; - byte unk7; - byte buildcmd_a; - byte buildcmd_b; - byte direction; - CargoID cargo; -}; - -struct CompanyAI { - byte state; - byte tick; ///< Used to determine how often to move - uint32 state_counter; ///< Can hold tile index! - uint16 timeout_counter; - - byte state_mode; - byte banned_tile_count; - RailTypeByte railtype_to_use; - - CargoID cargo_type; - byte num_wagons; - byte build_kind; - byte num_build_rec; - byte num_loco_to_build; - byte num_want_fullload; - - byte route_type_mask; - - TileIndex start_tile_a; - TileIndex cur_tile_a; - DiagDirectionByte cur_dir_a; - DiagDirectionByte start_dir_a; - - TileIndex start_tile_b; - TileIndex cur_tile_b; - DiagDirectionByte cur_dir_b; - DiagDirectionByte start_dir_b; - - Vehicle *cur_veh; ///< only used by some states - - AiBuildRec src, dst, mid1, mid2; - - VehicleID wagon_list[9]; - byte order_list_blocks[20]; - - TileIndex banned_tiles[16]; - byte banned_val[16]; -}; - -extern CompanyAI _companies_ai[MAX_COMPANIES]; - -#endif diff --git a/src/ai/trolly/build.cpp b/src/ai/trolly/build.cpp deleted file mode 100644 index 0723386f7..000000000 --- a/src/ai/trolly/build.cpp +++ /dev/null @@ -1,328 +0,0 @@ -/* $Id$ */ - -/** @file build.cpp Building support for the trolly AI. */ - -#include "../../stdafx.h" -#include "../../openttd.h" -#include "../../debug.h" -#include "../../road_map.h" -#include "../../command_func.h" -#include "trolly.h" -#include "../../engine_func.h" -#include "../../engine_base.h" -#include "../../variables.h" -#include "../../bridge.h" -#include "../../vehicle_func.h" -#include "../../vehicle_base.h" -#include "../../company_base.h" -#include "../../company_func.h" -#include "../ai.h" -#include "../../tunnelbridge.h" - - -// Build HQ -// Params: -// tile : tile where HQ is going to be build -bool AiNew_Build_CompanyHQ(Company *c, TileIndex tile) -{ - if (CmdFailed(AI_DoCommand(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ))) - return false; - AI_DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ); - return true; -} - - -// Build station -// Params: -// type : AI_TRAIN/AI_BUS/AI_TRUCK : indicates the type of station -// tile : tile where station is going to be build -// length : in case of AI_TRAIN: length of station -// numtracks : in case of AI_TRAIN: tracks of station -// direction : the direction of the station -// flag : flag passed to DoCommand (normally 0 to get the cost or DC_EXEC to build it) -CommandCost AiNew_Build_Station(Company *c, byte type, TileIndex tile, byte length, byte numtracks, byte direction, byte flag) -{ - if (type == AI_TRAIN) - return AI_DoCommand(tile, (direction << 4) + (numtracks << 8) + (length << 16), INVALID_STATION << 16, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_RAILROAD_STATION); - - if (type == AI_BUS) - return AI_DoCommand(tile, direction, ROADTYPES_ROAD << 2 | ROADSTOP_BUS | INVALID_STATION << 16, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_STOP); - - return AI_DoCommand(tile, direction, ROADTYPES_ROAD << 2 | ROADSTOP_TRUCK | INVALID_STATION << 16, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_STOP); -} - - -// Builds a brdige. The second best out of the ones available for this company -// Params: -// tile_a : starting point -// tile_b : end point -// flag : flag passed to DoCommand -CommandCost AiNew_Build_Bridge(Company *c, TileIndex tile_a, TileIndex tile_b, byte flag) -{ - int bridge_type, bridge_len, type, type2; - - // Find a good bridgetype (the best money can buy) - bridge_len = GetTunnelBridgeLength(tile_a, tile_b); - type = type2 = 0; - for (bridge_type = MAX_BRIDGES - 1; bridge_type >= 0; bridge_type--) { - if (CheckBridge_Stuff(bridge_type, bridge_len)) { - type2 = type; - type = bridge_type; - // We found two bridges, exit - if (type2 != 0) break; - } - } - // There is only one bridge that can be built - if (type2 == 0 && type != 0) type2 = type; - - // Now, simply, build the bridge! - if (_companies_ainew[c->index].tbt == AI_TRAIN) { - return AI_DoCommand(tile_a, tile_b, type2 | RAILTYPE_RAIL << 8 | TRANSPORT_RAIL << 15, flag | DC_AUTO, CMD_BUILD_BRIDGE); - } else { - return AI_DoCommand(tile_a, tile_b, type2 | ROADTYPES_ROAD << 8 | TRANSPORT_ROAD << 15, flag | DC_AUTO, CMD_BUILD_BRIDGE); - } -} - - -// Build the route part by part -// Basicly what this function do, is build that amount of parts of the route -// that go in the same direction. It sets 'part' to the last part of the route builded. -// The return value is the cost for the builded parts -// -// Params: -// PathFinderInfo : Pointer to the PathFinderInfo used for AiPathFinder -// part : Which part we need to build -// -// TODO: skip already builded road-pieces (e.g.: cityroad) -CommandCost AiNew_Build_RoutePart(Company *c, Ai_PathFinderInfo *PathFinderInfo, byte flag) -{ - int part = PathFinderInfo->position; - byte *route_extra = PathFinderInfo->route_extra; - TileIndex *route = PathFinderInfo->route; - int dir; - int old_dir = -1; - CommandCost cost; - CommandCost res; - // We need to calculate the direction with the parent of the parent.. so we skip - // the first pieces and the last piece - if (part < 1) part = 1; - // When we are done, stop it - if (part >= PathFinderInfo->route_length - 1) { - PathFinderInfo->position = -2; - return CommandCost(); - } - - - if (PathFinderInfo->rail_or_road) { - // Tunnel code - if ((AI_PATHFINDER_FLAG_TUNNEL & route_extra[part]) != 0) { - cost.AddCost(AI_DoCommand(route[part], 0, 0, flag, CMD_BUILD_TUNNEL)); - PathFinderInfo->position++; - // TODO: problems! - if (CmdFailed(cost)) { - DEBUG(ai, 0, "[BuildPath] tunnel could not be built (0x%X)", route[part]); - return CommandCost(); - } - return cost; - } - // Bridge code - if ((AI_PATHFINDER_FLAG_BRIDGE & route_extra[part]) != 0) { - cost.AddCost(AiNew_Build_Bridge(c, route[part], route[part - 1], flag)); - PathFinderInfo->position++; - // TODO: problems! - if (CmdFailed(cost)) { - DEBUG(ai, 0, "[BuildPath] bridge could not be built (0x%X, 0x%X)", route[part], route[part - 1]); - return CommandCost(); - } - return cost; - } - - // Build normal rail - // Keep it doing till we go an other way - if (route_extra[part - 1] == 0 && route_extra[part] == 0) { - while (route_extra[part] == 0) { - // Get the current direction - dir = AiNew_GetRailDirection(route[part - 1], route[part], route[part + 1]); - // Is it the same as the last one? - if (old_dir != -1 && old_dir != dir) break; - old_dir = dir; - // Build the tile - res = AI_DoCommand(route[part], 0, dir, flag, CMD_BUILD_SINGLE_RAIL); - if (CmdFailed(res)) { - // Problem.. let's just abort it all! - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return CommandCost(); - } - cost.AddCost(res); - // Go to the next tile - part++; - // Check if it is still in range.. - if (part >= PathFinderInfo->route_length - 1) break; - } - part--; - } - // We want to return the last position, so we go back one - PathFinderInfo->position = part; - } else { - // Tunnel code - if ((AI_PATHFINDER_FLAG_TUNNEL & route_extra[part]) != 0) { - cost.AddCost(AI_DoCommand(route[part], 0x200 | ROADTYPES_ROAD, 0, flag, CMD_BUILD_TUNNEL)); - PathFinderInfo->position++; - // TODO: problems! - if (CmdFailed(cost)) { - DEBUG(ai, 0, "[BuildPath] tunnel could not be built (0x%X)", route[part]); - return CommandCost(); - } - return cost; - } - // Bridge code - if ((AI_PATHFINDER_FLAG_BRIDGE & route_extra[part]) != 0) { - cost.AddCost(AiNew_Build_Bridge(c, route[part], route[part + 1], flag)); - PathFinderInfo->position++; - // TODO: problems! - if (CmdFailed(cost)) { - DEBUG(ai, 0, "[BuildPath] bridge could not be built (0x%X, 0x%X)", route[part], route[part + 1]); - return CommandCost(); - } - return cost; - } - - // Build normal road - // Keep it doing till we go an other way - // EnsureNoVehicleOnGround makes sure we don't build on a tile where a vehicle is. This way - // it will wait till the vehicle is gone.. - if (route_extra[part - 1] == 0 && route_extra[part] == 0 && (flag != DC_EXEC || EnsureNoVehicleOnGround(route[part]))) { - while (route_extra[part] == 0 && (flag != DC_EXEC || EnsureNoVehicleOnGround(route[part]))) { - // Get the current direction - dir = AiNew_GetRoadDirection(route[part - 1], route[part], route[part + 1]); - // Is it the same as the last one? - if (old_dir != -1 && old_dir != dir) break; - old_dir = dir; - // There is already some road, and it is a bridge.. don't build!!! - if (!IsTileType(route[part], MP_TUNNELBRIDGE)) { - // Build the tile - res = AI_DoCommand(route[part], dir, 0, flag | DC_NO_WATER, CMD_BUILD_ROAD); - // Currently, we ignore CMD_ERRORs! - if (CmdFailed(res) && flag == DC_EXEC && !IsTileType(route[part], MP_ROAD) && !EnsureNoVehicleOnGround(route[part])) { - // Problem.. let's just abort it all! - DEBUG(ai, 0, "[BuidPath] route building failed at tile 0x%X, aborting", route[part]); - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return CommandCost(); - } - - if (CmdSucceeded(res)) cost.AddCost(res); - } - // Go to the next tile - part++; - // Check if it is still in range.. - if (part >= PathFinderInfo->route_length - 1) break; - } - part--; - // We want to return the last position, so we go back one - } - if (!EnsureNoVehicleOnGround(route[part]) && flag == DC_EXEC) part--; - PathFinderInfo->position = part; - } - - return cost; -} - - -// This functions tries to find the best vehicle for this type of cargo -// It returns INVALID_ENGINE if not suitable engine is found -EngineID AiNew_PickVehicle(Company *c) -{ - if (_companies_ainew[c->index].tbt == AI_TRAIN) { - // Not supported yet - return INVALID_ENGINE; - } else { - EngineID best_veh_index = INVALID_ENGINE; - int32 best_veh_rating = 0; - const Engine *e; - - /* Loop through all road vehicles */ - FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) { - EngineID i = e->index; - const RoadVehicleInfo *rvi = &e->u.road; - - /* Skip vehicles which can't take our cargo type */ - if (rvi->cargo_type != _companies_ainew[c->index].cargo && !CanRefitTo(i, _companies_ainew[c->index].cargo)) continue; - - /* Skip trams */ - if (HasBit(EngInfo(i)->misc_flags, EF_ROAD_TRAM)) continue; - - // Is it availiable? - // Also, check if the reliability of the vehicle is above the AI_VEHICLE_MIN_RELIABILTY - if (!HasBit(e->company_avail, _current_company) || e->reliability * 100 < AI_VEHICLE_MIN_RELIABILTY << 16) continue; - - /* Rate and compare the engine by speed & capacity */ - int rating = rvi->max_speed * rvi->capacity; - if (rating <= best_veh_rating) continue; - - // Can we build it? - CommandCost ret = AI_DoCommand(0, i, 0, DC_QUERY_COST, CMD_BUILD_ROAD_VEH); - if (CmdFailed(ret)) continue; - - best_veh_rating = rating; - best_veh_index = i; - } - - return best_veh_index; - } -} - - -void CcAI(bool success, TileIndex tile, uint32 p1, uint32 p2) -{ - Company *c = GetCompany(_current_company); - - if (success) { - _companies_ainew[c->index].state = AI_STATE_GIVE_ORDERS; - _companies_ainew[c->index].veh_id = _new_vehicle_id; - - if (GetVehicle(_companies_ainew[c->index].veh_id)->cargo_type != _companies_ainew[c->index].cargo) { - /* Cargo type doesn't match, so refit it */ - if (CmdFailed(DoCommand(tile, _companies_ainew[c->index].veh_id, _companies_ainew[c->index].cargo, DC_EXEC, CMD_REFIT_ROAD_VEH))) { - /* Refit failed, so sell the vehicle */ - DoCommand(tile, _companies_ainew[c->index].veh_id, 0, DC_EXEC, CMD_SELL_ROAD_VEH); - _companies_ainew[c->index].state = AI_STATE_NOTHING; - } - } - } else { - /* XXX this should be handled more gracefully */ - _companies_ainew[c->index].state = AI_STATE_NOTHING; - } -} - - -// Builds the best vehicle possible -CommandCost AiNew_Build_Vehicle(Company *c, TileIndex tile, byte flag) -{ - EngineID i = AiNew_PickVehicle(c); - - if (i == INVALID_ENGINE) return CMD_ERROR; - if (_companies_ainew[c->index].tbt == AI_TRAIN) return CMD_ERROR; - - if (flag & DC_EXEC) { - return AI_DoCommandCc(tile, i, 0, flag, CMD_BUILD_ROAD_VEH, CcAI); - } else { - return AI_DoCommand(tile, i, 0, flag, CMD_BUILD_ROAD_VEH); - } -} - -CommandCost AiNew_Build_Depot(Company *c, TileIndex tile, DiagDirection direction, byte flag) -{ - CommandCost ret, ret2; - if (_companies_ainew[c->index].tbt == AI_TRAIN) { - return AI_DoCommand(tile, 0, direction, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_TRAIN_DEPOT); - } else { - ret = AI_DoCommand(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_DEPOT); - if (CmdFailed(ret2)) return ret; - // Try to build the road from the depot - ret2 = AI_DoCommand(tile + TileOffsByDiagDir(direction), DiagDirToRoadBits(ReverseDiagDir(direction)), 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD); - // If it fails, ignore it.. - if (CmdFailed(ret2)) return ret; - ret.AddCost(ret2); - return ret; - } -} diff --git a/src/ai/trolly/pathfinder.cpp b/src/ai/trolly/pathfinder.cpp deleted file mode 100644 index 0e08ddf77..000000000 --- a/src/ai/trolly/pathfinder.cpp +++ /dev/null @@ -1,482 +0,0 @@ -/* $Id$ */ - -/** @file pathfinder.cpp Pathfinder support for the trolly AI. */ - -#include "../../stdafx.h" -#include "../../openttd.h" -#include "../../bridge_map.h" -#include "../../debug.h" -#include "../../command_func.h" -#include "trolly.h" -#include "../../tunnel_map.h" -#include "../../bridge.h" -#include "../../tunnelbridge_map.h" -#include "../ai.h" -#include "../../variables.h" -#include "../../company_base.h" -#include "../../company_func.h" -#include "../../tunnelbridge.h" - - -#define TEST_STATION_NO_DIR 0xFF - -// Tests if a station can be build on the given spot -// TODO: make it train compatible -static bool TestCanBuildStationHere(TileIndex tile, byte dir) -{ - Company *c = GetCompany(_current_company); - - if (dir == TEST_STATION_NO_DIR) { - CommandCost ret; - // TODO: currently we only allow spots that can be access from al 4 directions... - // should be fixed!!! - for (dir = 0; dir < 4; dir++) { - ret = AiNew_Build_Station(c, _companies_ainew[c->index].tbt, tile, 1, 1, dir, DC_QUERY_COST); - if (CmdSucceeded(ret)) return true; - } - return false; - } - - // return true if command succeeded, so the inverse of CmdFailed() - return CmdSucceeded(AiNew_Build_Station(c, _companies_ainew[c->index].tbt, tile, 1, 1, dir, DC_QUERY_COST)); -} - - -static bool IsRoad(TileIndex tile) -{ - return - // MP_ROAD, but not a road depot? - (IsTileType(tile, MP_ROAD) && !IsRoadDepot(tile)) || - (IsTileType(tile, MP_TUNNELBRIDGE) && GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD); -} - - -// Checks if a tile 'a' is between the tiles 'b' and 'c' -#define TILES_BETWEEN(a, b, c) (TileX(a) >= TileX(b) && TileX(a) <= TileX(c) && TileY(a) >= TileY(b) && TileY(a) <= TileY(c)) - - -// Check if the current tile is in our end-area -static int32 AyStar_AiPathFinder_EndNodeCheck(AyStar *aystar, OpenListNode *current) -{ - const Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target; - - // It is not allowed to have a station on the end of a bridge or tunnel ;) - if (current->path.node.user_data[0] != 0) return AYSTAR_DONE; - if (TILES_BETWEEN(current->path.node.tile, PathFinderInfo->end_tile_tl, PathFinderInfo->end_tile_br)) - if (IsTileType(current->path.node.tile, MP_CLEAR) || IsTileType(current->path.node.tile, MP_TREES)) - if (current->path.parent == NULL || TestCanBuildStationHere(current->path.node.tile, AiNew_GetDirection(current->path.parent->node.tile, current->path.node.tile))) - return AYSTAR_FOUND_END_NODE; - - return AYSTAR_DONE; -} - - -// Calculates the hash -// Currently it is a 10 bit hash, so the hash array has a max depth of 6 bits (so 64) -static uint AiPathFinder_Hash(uint key1, uint key2) -{ - return (TileX(key1) & 0x1F) + ((TileY(key1) & 0x1F) << 5); -} - - -// Clear the memory of all the things -static void AyStar_AiPathFinder_Free(AyStar *aystar) -{ - AyStarMain_Free(aystar); - delete aystar; -} - - -static int32 AyStar_AiPathFinder_CalculateG(AyStar *aystar, AyStarNode *current, OpenListNode *parent); -static int32 AyStar_AiPathFinder_CalculateH(AyStar *aystar, AyStarNode *current, OpenListNode *parent); -static void AyStar_AiPathFinder_FoundEndNode(AyStar *aystar, OpenListNode *current); -static void AyStar_AiPathFinder_GetNeighbours(AyStar *aystar, OpenListNode *current); - - -// This creates the AiPathFinder -AyStar *new_AyStar_AiPathFinder(int max_tiles_around, Ai_PathFinderInfo *PathFinderInfo) -{ - PathNode start_node; - uint x; - uint y; - // Create AyStar - AyStar *result = new AyStar(); - init_AyStar(result, AiPathFinder_Hash, 1 << 10); - // Set the function pointers - result->CalculateG = AyStar_AiPathFinder_CalculateG; - result->CalculateH = AyStar_AiPathFinder_CalculateH; - result->EndNodeCheck = AyStar_AiPathFinder_EndNodeCheck; - result->FoundEndNode = AyStar_AiPathFinder_FoundEndNode; - result->GetNeighbours = AyStar_AiPathFinder_GetNeighbours; - - result->free = AyStar_AiPathFinder_Free; - - // Set some information - result->loops_per_tick = AI_PATHFINDER_LOOPS_PER_TICK; - result->max_path_cost = 0; - result->max_search_nodes = AI_PATHFINDER_MAX_SEARCH_NODES; - - // Set the user_data to the PathFinderInfo - result->user_target = PathFinderInfo; - - // Set the start node - start_node.parent = NULL; - start_node.node.direction = INVALID_TRACKDIR; - start_node.node.user_data[0] = 0; - - // Now we add all the starting tiles - for (x = TileX(PathFinderInfo->start_tile_tl); x <= TileX(PathFinderInfo->start_tile_br); x++) { - for (y = TileY(PathFinderInfo->start_tile_tl); y <= TileY(PathFinderInfo->start_tile_br); y++) { - start_node.node.tile = TileXY(x, y); - result->addstart(result, &start_node.node, 0); - } - } - - return result; -} - - -// To reuse AyStar we sometimes have to clean all the memory -void clean_AyStar_AiPathFinder(AyStar *aystar, Ai_PathFinderInfo *PathFinderInfo) -{ - PathNode start_node; - uint x; - uint y; - - aystar->clear(aystar); - - // Set the user_data to the PathFinderInfo - aystar->user_target = PathFinderInfo; - - // Set the start node - start_node.parent = NULL; - start_node.node.direction = INVALID_TRACKDIR; - start_node.node.user_data[0] = 0; - start_node.node.tile = PathFinderInfo->start_tile_tl; - - // Now we add all the starting tiles - for (x = TileX(PathFinderInfo->start_tile_tl); x <= TileX(PathFinderInfo->start_tile_br); x++) { - for (y = TileY(PathFinderInfo->start_tile_tl); y <= TileY(PathFinderInfo->start_tile_br); y++) { - TileIndex tile = TileXY(x, y); - - if (!IsTileType(tile, MP_CLEAR) && !IsTileType(tile, MP_TREES)) continue; - if (!TestCanBuildStationHere(tile, TEST_STATION_NO_DIR)) continue; - start_node.node.tile = tile; - aystar->addstart(aystar, &start_node.node, 0); - } - } -} - - -// The h-value, simple calculation -static int32 AyStar_AiPathFinder_CalculateH(AyStar *aystar, AyStarNode *current, OpenListNode *parent) -{ - const Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target; - int r, r2; - - if (PathFinderInfo->end_direction != AI_PATHFINDER_NO_DIRECTION) { - // The station is pointing to a direction, add a tile towards that direction, so the H-value is more accurate - r = DistanceManhattan(current->tile, PathFinderInfo->end_tile_tl + TileOffsByDiagDir(PathFinderInfo->end_direction)); - r2 = DistanceManhattan(current->tile, PathFinderInfo->end_tile_br + TileOffsByDiagDir(PathFinderInfo->end_direction)); - } else { - // No direction, so just get the fastest route to the station - r = DistanceManhattan(current->tile, PathFinderInfo->end_tile_tl); - r2 = DistanceManhattan(current->tile, PathFinderInfo->end_tile_br); - } - // See if the bottomright is faster than the topleft.. - if (r2 < r) r = r2; - return r * AI_PATHFINDER_H_MULTIPLER; -} - - -// We found the end.. let's get the route back and put it in an array -static void AyStar_AiPathFinder_FoundEndNode(AyStar *aystar, OpenListNode *current) -{ - Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target; - uint i = 0; - PathNode *parent = ¤t->path; - - do { - PathFinderInfo->route_extra[i] = parent->node.user_data[0]; - PathFinderInfo->route[i++] = parent->node.tile; - if (i > lengthof(PathFinderInfo->route)) { - // We ran out of space for the PathFinder - DEBUG(ai, 0, "No more space in pathfinder route[] array"); - PathFinderInfo->route_length = -1; // -1 indicates out of space - return; - } - parent = parent->parent; - } while (parent != NULL); - PathFinderInfo->route_length = i; - DEBUG(ai, 1, "Found route of %d nodes long in %d nodes of searching", i, Hash_Size(&aystar->ClosedListHash)); -} - - -// What tiles are around us. -static void AyStar_AiPathFinder_GetNeighbours(AyStar *aystar, OpenListNode *current) -{ - CommandCost ret; - int dir; - - Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target; - - aystar->num_neighbours = 0; - - // Go through all surrounding tiles and check if they are within the limits - for (DiagDirection i = DIAGDIR_BEGIN; i < DIAGDIR_END; i++) { - TileIndex ctile = current->path.node.tile; // Current tile - TileIndex atile = ctile + TileOffsByDiagDir(i); // Adjacent tile - - if (TileX(atile) > 1 && TileX(atile) < MapMaxX() - 1 && - TileY(atile) > 1 && TileY(atile) < MapMaxY() - 1) { - // We also directly test if the current tile can connect to this tile.. - // We do this simply by just building the tile! - - // If the next step is a bridge, we have to enter it the right way - if (!PathFinderInfo->rail_or_road && IsRoad(atile)) { - if (IsTileType(atile, MP_TUNNELBRIDGE)) { - if (GetTunnelBridgeDirection(atile) != i) continue; - } - } - - if ((AI_PATHFINDER_FLAG_BRIDGE & current->path.node.user_data[0]) != 0 || - (AI_PATHFINDER_FLAG_TUNNEL & current->path.node.user_data[0]) != 0) { - // We are a bridge/tunnel, how cool!! - // This means we can only point forward.. get the direction from the user_data - if ((uint)i != (current->path.node.user_data[0] >> 8)) continue; - } - dir = 0; - - // First, check if we have a parent - if (current->path.parent == NULL && current->path.node.user_data[0] == 0) { - // If not, this means we are at the starting station - if (PathFinderInfo->start_direction != AI_PATHFINDER_NO_DIRECTION) { - // We do need a direction? - if (AiNew_GetDirection(ctile, atile) != PathFinderInfo->start_direction) { - // We are not pointing the right way, invalid tile - continue; - } - } - } else if (current->path.node.user_data[0] == 0) { - if (PathFinderInfo->rail_or_road) { - // Rail check - dir = AiNew_GetRailDirection(current->path.parent->node.tile, ctile, atile); - ret = AI_DoCommand(ctile, 0, dir, DC_AUTO | DC_NO_WATER, CMD_BUILD_SINGLE_RAIL); - if (CmdFailed(ret)) continue; -#ifdef AI_PATHFINDER_NO_90DEGREES_TURN - if (current->path.parent->parent != NULL) { - // Check if we don't make a 90degree curve - int dir1 = AiNew_GetRailDirection(current->path.parent->parent->node.tile, current->path.parent->node.tile, ctile); - if (_illegal_curves[dir1] == dir || _illegal_curves[dir] == dir1) { - continue; - } - } -#endif - } else { - // Road check - dir = AiNew_GetRoadDirection(current->path.parent->node.tile, ctile, atile); - if (IsRoad(ctile)) { - if (IsTileType(ctile, MP_TUNNELBRIDGE)) { - // We have a bridge, how nicely! We should mark it... - dir = 0; - } else { - // It already has road.. check if we miss any bits! - if ((GetAnyRoadBits(ctile, ROADTYPE_ROAD) & dir) != dir) { - // We do miss some pieces :( - dir &= ~GetAnyRoadBits(ctile, ROADTYPE_ROAD); - } else { - dir = 0; - } - } - } - // Only destruct things if it is MP_CLEAR of MP_TREES - if (dir != 0) { - ret = AI_DoCommand(ctile, dir, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD); - if (CmdFailed(ret)) continue; - } - } - } - - // The tile can be connected - aystar->neighbours[aystar->num_neighbours].tile = atile; - aystar->neighbours[aystar->num_neighbours].user_data[0] = 0; - aystar->neighbours[aystar->num_neighbours++].direction = INVALID_TRACKDIR; - } - } - - // Next step, check for bridges and tunnels - if (current->path.parent != NULL && current->path.node.user_data[0] == 0) { - // First we get the dir from this tile and his parent - DiagDirection dir = AiNew_GetDirection(current->path.parent->node.tile, current->path.node.tile); - // It means we can only walk with the track, so the bridge has to be in the same direction - TileIndex tile = current->path.node.tile; - TileIndex new_tile = tile; - Slope tileh = GetTileSlope(tile, NULL); - - // Bridges can only be build on land that is not flat - // And if there is a road or rail blocking - if (tileh != SLOPE_FLAT || - (PathFinderInfo->rail_or_road && IsTileType(tile + TileOffsByDiagDir(dir), MP_ROAD)) || - (!PathFinderInfo->rail_or_road && IsTileType(tile + TileOffsByDiagDir(dir), MP_RAILWAY))) { - for (;;) { - new_tile += TileOffsByDiagDir(dir); - - // Precheck, is the length allowed? - if (!CheckBridge_Stuff(0, GetTunnelBridgeLength(tile, new_tile))) break; - - // Check if we hit the station-tile.. we don't like that! - if (TILES_BETWEEN(new_tile, PathFinderInfo->end_tile_tl, PathFinderInfo->end_tile_br)) break; - - // Try building the bridge.. - ret = AI_DoCommand(tile, new_tile, (0 << 8) + (MAX_BRIDGES / 2), DC_AUTO, CMD_BUILD_BRIDGE); - if (CmdFailed(ret)) continue; - // We can build a bridge here.. add him to the neighbours - aystar->neighbours[aystar->num_neighbours].tile = new_tile; - aystar->neighbours[aystar->num_neighbours].user_data[0] = AI_PATHFINDER_FLAG_BRIDGE + (dir << 8); - aystar->neighbours[aystar->num_neighbours++].direction = INVALID_TRACKDIR; - // We can only have 12 neighbours, and we need 1 left for tunnels - if (aystar->num_neighbours == 11) break; - } - } - - // Next, check for tunnels! - // Tunnels can only be built on slopes corresponding to the direction - // For now, we check both sides for this tile.. terraforming gives fuzzy result - if (tileh == InclinedSlope(dir)) { - // Now simply check if a tunnel can be build - ret = AI_DoCommand(tile, (PathFinderInfo->rail_or_road ? 0 : 0x200), 0, DC_AUTO, CMD_BUILD_TUNNEL); - tileh = GetTileSlope(_build_tunnel_endtile, NULL); - if (CmdSucceeded(ret) && IsInclinedSlope(tileh)) { - aystar->neighbours[aystar->num_neighbours].tile = _build_tunnel_endtile; - aystar->neighbours[aystar->num_neighbours].user_data[0] = AI_PATHFINDER_FLAG_TUNNEL + (dir << 8); - aystar->neighbours[aystar->num_neighbours++].direction = INVALID_TRACKDIR; - } - } - } -} - - -extern Foundation GetRailFoundation(Slope tileh, TrackBits bits); // XXX function declaration in .c -extern Foundation GetRoadFoundation(Slope tileh, RoadBits bits); // XXX function declaration in .c - -// The most important function: it calculates the g-value -static int32 AyStar_AiPathFinder_CalculateG(AyStar *aystar, AyStarNode *current, OpenListNode *parent) -{ - Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target; - int res = 0; - Slope tileh = GetTileSlope(current->tile, NULL); - Slope parent_tileh = GetTileSlope(parent->path.node.tile, NULL); - - // Check if we hit the end-tile - if (TILES_BETWEEN(current->tile, PathFinderInfo->end_tile_tl, PathFinderInfo->end_tile_br)) { - // We are at the end-tile, check if we had a direction or something... - if (PathFinderInfo->end_direction != AI_PATHFINDER_NO_DIRECTION && AiNew_GetDirection(current->tile, parent->path.node.tile) != PathFinderInfo->end_direction) { - // We are not pointing the right way, invalid tile - return AYSTAR_INVALID_NODE; - } - // If it was valid, drop out.. we don't build on the endtile - return 0; - } - - // Give everything a small penalty - res += AI_PATHFINDER_PENALTY; - - if (!PathFinderInfo->rail_or_road) { - // Road has the lovely advantage it can use other road... check if - // the current tile is road, and if so, give a good bonus - if (IsRoad(current->tile)) { - res -= AI_PATHFINDER_ROAD_ALREADY_EXISTS_BONUS; - } - } - - // We should give a penalty when the tile is going up or down.. this is one way to do so! - // Too bad we have to count it from the parent.. but that is not so bad. - // We also dislike long routes on slopes, since they do not look too realistic - // when there is a flat land all around, they are more expensive to build, and - // especially they essentially block the ability to connect or cross the road - // from one side. - if (parent_tileh != SLOPE_FLAT && parent->path.parent != NULL) { - // Skip if the tile was from a bridge or tunnel - if (parent->path.node.user_data[0] == 0 && current->user_data[0] == 0) { - if (PathFinderInfo->rail_or_road) { - Foundation f = GetRailFoundation(parent_tileh, (TrackBits)(1 << AiNew_GetRailDirection(parent->path.parent->node.tile, parent->path.node.tile, current->tile))); - if (IsInclinedFoundation(f) || (!IsFoundation(f) && IsInclinedSlope(parent_tileh))) { - res += AI_PATHFINDER_TILE_GOES_UP_PENALTY; - } else { - res += AI_PATHFINDER_FOUNDATION_PENALTY; - } - } else { - if (!IsRoad(parent->path.node.tile) || !IsTileType(parent->path.node.tile, MP_TUNNELBRIDGE)) { - Foundation f = GetRoadFoundation(parent_tileh, (RoadBits)AiNew_GetRoadDirection(parent->path.parent->node.tile, parent->path.node.tile, current->tile)); - if (IsInclinedFoundation(f) || (!IsFoundation(f) && IsInclinedSlope(parent_tileh))) { - res += AI_PATHFINDER_TILE_GOES_UP_PENALTY; - } else { - res += AI_PATHFINDER_FOUNDATION_PENALTY; - } - } - } - } - } - - // Are we part of a tunnel? - if ((AI_PATHFINDER_FLAG_TUNNEL & current->user_data[0]) != 0) { - int r; - // Tunnels are very expensive when build on long routes.. - // Ironicly, we are using BridgeCode here ;) - r = AI_PATHFINDER_TUNNEL_PENALTY * GetTunnelBridgeLength(current->tile, parent->path.node.tile); - res += r + (r >> 8); - } - - // Are we part of a bridge? - if ((AI_PATHFINDER_FLAG_BRIDGE & current->user_data[0]) != 0) { - // That means for every length a penalty - res += AI_PATHFINDER_BRIDGE_PENALTY * GetTunnelBridgeLength(current->tile, parent->path.node.tile); - // Check if we are going up or down, first for the starting point - // In user_data[0] is at the 8th bit the direction - if (!HasBridgeFlatRamp(parent_tileh, (Axis)((current->user_data[0] >> 8) & 1))) res += AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY; - // Second for the end point - if (!HasBridgeFlatRamp(tileh, (Axis)((current->user_data[0] >> 8) & 1))) res += AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY; - } - - // To prevent the AI from taking the fastest way in tiles, but not the fastest way - // in speed, we have to give a good penalty to direction changing - // This way, we get almost the fastest way in tiles, and a very good speed on the track - if (!PathFinderInfo->rail_or_road) { - if (parent->path.parent != NULL && - AiNew_GetDirection(current->tile, parent->path.node.tile) != AiNew_GetDirection(parent->path.node.tile, parent->path.parent->node.tile)) { - // When road exists, we don't like turning, but its free, so don't be to piggy about it - if (IsRoad(parent->path.node.tile)) { - res += AI_PATHFINDER_DIRECTION_CHANGE_ON_EXISTING_ROAD_PENALTY; - } else { - res += AI_PATHFINDER_DIRECTION_CHANGE_PENALTY; - } - } - } else { - // For rail we have 1 exeption: diagonal rail.. - // So we fetch 2 raildirection. That of the current one, and of the one before that - if (parent->path.parent != NULL && parent->path.parent->parent != NULL) { - int dir1 = AiNew_GetRailDirection(parent->path.parent->node.tile, parent->path.node.tile, current->tile); - int dir2 = AiNew_GetRailDirection(parent->path.parent->parent->node.tile, parent->path.parent->node.tile, parent->path.node.tile); - // First, see if we are on diagonal path, that is better than straight path - if (dir1 > 1) res -= AI_PATHFINDER_DIAGONAL_BONUS; - - // First see if they are different - if (dir1 != dir2) { - // dir 2 and 3 are 1 diagonal track, and 4 and 5. - if (!(((dir1 == 2 || dir1 == 3) && (dir2 == 2 || dir2 == 3)) || ((dir1 == 4 || dir1 == 5) && (dir2 == 4 || dir2 == 5)))) { - // It is not, so we changed of direction - res += AI_PATHFINDER_DIRECTION_CHANGE_PENALTY; - } - if (parent->path.parent->parent->parent != NULL) { - int dir3 = AiNew_GetRailDirection(parent->path.parent->parent->parent->node.tile, parent->path.parent->parent->node.tile, parent->path.parent->node.tile); - // Check if we changed 3 tiles of direction in 3 tiles.. bad!!! - if ((dir1 == 0 || dir1 == 1) && dir2 > 1 && (dir3 == 0 || dir3 == 1)) { - res += AI_PATHFINDER_CURVE_PENALTY; - } - } - } - } - } - - return (res < 0) ? 0 : res; -} diff --git a/src/ai/trolly/shared.cpp b/src/ai/trolly/shared.cpp deleted file mode 100644 index 1183f0371..000000000 --- a/src/ai/trolly/shared.cpp +++ /dev/null @@ -1,121 +0,0 @@ -/* $Id$ */ - -/** @file shared.cpp Shared functions for the trolly AI. */ - -#include "../../stdafx.h" -#include "../../openttd.h" -#include "../../debug.h" -#include "../../map_func.h" -#include "../../vehicle_base.h" -#include "../../company_base.h" -#include "trolly.h" - -int AiNew_GetRailDirection(TileIndex tile_a, TileIndex tile_b, TileIndex tile_c) -{ - // 0 = vert - // 1 = horz - // 2 = dig up-left - // 3 = dig down-right - // 4 = dig down-left - // 5 = dig up-right - - uint x1 = TileX(tile_a); - uint x2 = TileX(tile_b); - uint x3 = TileX(tile_c); - - uint y1 = TileY(tile_a); - uint y2 = TileY(tile_b); - uint y3 = TileY(tile_c); - - if (y1 == y2 && y2 == y3) return 0; - if (x1 == x2 && x2 == x3) return 1; - if (y2 > y1) return x2 > x3 ? 2 : 4; - if (x2 > x1) return y2 > y3 ? 2 : 5; - if (y1 > y2) return x2 > x3 ? 5 : 3; - if (x1 > x2) return y2 > y3 ? 4 : 3; - - return 0; -} - -int AiNew_GetRoadDirection(TileIndex tile_a, TileIndex tile_b, TileIndex tile_c) -{ - int x1, x2, x3; - int y1, y2, y3; - int r; - - x1 = TileX(tile_a); - x2 = TileX(tile_b); - x3 = TileX(tile_c); - - y1 = TileY(tile_a); - y2 = TileY(tile_b); - y3 = TileY(tile_c); - - r = 0; - - if (x1 < x2) r += 8; - if (y1 < y2) r += 1; - if (x1 > x2) r += 2; - if (y1 > y2) r += 4; - - if (x2 < x3) r += 2; - if (y2 < y3) r += 4; - if (x2 > x3) r += 8; - if (y2 > y3) r += 1; - - return r; -} - -// Get's the direction between 2 tiles seen from tile_a -DiagDirection AiNew_GetDirection(TileIndex tile_a, TileIndex tile_b) -{ - if (TileY(tile_a) < TileY(tile_b)) return DIAGDIR_SE; - if (TileY(tile_a) > TileY(tile_b)) return DIAGDIR_NW; - if (TileX(tile_a) < TileX(tile_b)) return DIAGDIR_SW; - return DIAGDIR_NE; -} - - -// This functions looks up if this vehicle is special for this AI -// and returns his flag -uint AiNew_GetSpecialVehicleFlag(Company *c, Vehicle *v) -{ - uint i; - - for (i = 0; i < AI_MAX_SPECIAL_VEHICLES; i++) { - if (_companies_ainew[c->index].special_vehicles[i].veh_id == v->index) { - return _companies_ainew[c->index].special_vehicles[i].flag; - } - } - - // Not found :( - return 0; -} - - -bool AiNew_SetSpecialVehicleFlag(Company *c, Vehicle *v, uint flag) -{ - int new_id = -1; - uint i; - - for (i = 0; i < AI_MAX_SPECIAL_VEHICLES; i++) { - if (_companies_ainew[c->index].special_vehicles[i].veh_id == v->index) { - _companies_ainew[c->index].special_vehicles[i].flag |= flag; - return true; - } - if (new_id == -1 && - _companies_ainew[c->index].special_vehicles[i].veh_id == 0 && - _companies_ainew[c->index].special_vehicles[i].flag == 0) { - new_id = i; - } - } - - // Out of special_vehicle spots :s - if (new_id == -1) { - DEBUG(ai, 1, "special_vehicles list is too small"); - return false; - } - _companies_ainew[c->index].special_vehicles[new_id].veh_id = v->index; - _companies_ainew[c->index].special_vehicles[new_id].flag = flag; - return true; -} diff --git a/src/ai/trolly/trolly.cpp b/src/ai/trolly/trolly.cpp deleted file mode 100644 index 6b874ec0d..000000000 --- a/src/ai/trolly/trolly.cpp +++ /dev/null @@ -1,1348 +0,0 @@ -/* $Id$ */ - -/** - * @file trolly.cpp Implementation of the trolly AI. - * - * This AI was created as a direct reaction to the big demand for some good AIs - * in OTTD. Too bad it never left alpha-stage, and it is considered dead in its - * current form. - * By the time of writing this, we, the creator of this AI and a good friend of - * mine, are designing a whole new AI-system that allows us to create AIs - * easier and without all the fuzz we encountered while I was working on this - * AI. By the time that system is finished, you can expect that this AI will - * dissapear, because it is pretty obselete and bad programmed. - * - * Meanwhile I wish you all much fun with this AI; if you are interested as - * AI-developer in this AI, I advise you not stare too long to some code, some - * things in here really are... strange ;) But in either way: enjoy :) - * - * -- TrueLight :: 2005-09-01 - */ - -#include "../../stdafx.h" -#include "../../openttd.h" -#include "../../debug.h" -#include "../../road_map.h" -#include "../../station_map.h" -#include "../../command_func.h" -#include "trolly.h" -#include "../../depot_base.h" -#include "../../town.h" -#include "../../industry.h" -#include "../../station_base.h" -#include "../../engine_func.h" -#include "../../engine_base.h" -#include "../../gui.h" -#include "../../vehicle_base.h" -#include "../../vehicle_func.h" -#include "../../date_func.h" -#include "../ai.h" -#include "../../company_base.h" -#include "../../company_func.h" - -#include "table/strings.h" - -CompanyAiNew _companies_ainew[MAX_COMPANIES]; - -// This function is called after StartUp. It is the init of an AI -static void AiNew_State_FirstTime(Company *c) -{ - // This assert is used to protect those function from misuse - // You have quickly a small mistake in the state-array - // With that, everything would go wrong. Finding that, is almost impossible - // With this assert, that problem can never happen. - assert(_companies_ainew[c->index].state == AI_STATE_FIRST_TIME); - // We first have to init some things - - if (_current_company == 1) ShowErrorMessage(INVALID_STRING_ID, TEMP_AI_IN_PROGRESS, 0, 0); - - // The PathFinder (AyStar) - // TODO: Maybe when an AI goes bankrupt, this is de-init - // or when coming from a savegame.. should be checked out! - _companies_ainew[c->index].path_info.start_tile_tl = 0; - _companies_ainew[c->index].path_info.start_tile_br = 0; - _companies_ainew[c->index].path_info.end_tile_tl = 0; - _companies_ainew[c->index].path_info.end_tile_br = 0; - _companies_ainew[c->index].pathfinder = new_AyStar_AiPathFinder(12, &_companies_ainew[c->index].path_info); - - _companies_ainew[c->index].idle = 0; - _companies_ainew[c->index].last_vehiclecheck_date = _date; - - // We ALWAYS start with a bus route.. just some basic money ;) - _companies_ainew[c->index].action = AI_ACTION_BUS_ROUTE; - - // Let's popup the news, and after that, start building.. - _companies_ainew[c->index].state = AI_STATE_WAKE_UP; -} - - -// This function just waste some time -// It keeps it more real. The AI can build on such tempo no normal user -// can ever keep up with that. The competitor_speed already delays a bit -// but after the AI finished a track it really needs to go to sleep. -// -// Let's say, we sleep between one and three days if the AI is put on Very Fast. -// This means that on Very Slow it will be between 16 and 48 days.. slow enough? -static void AiNew_State_Nothing(Company *c) -{ - assert(_companies_ainew[c->index].state == AI_STATE_NOTHING); - // If we are done idling, start over again - if (_companies_ainew[c->index].idle == 0) _companies_ainew[c->index].idle = AI_RandomRange(DAY_TICKS * 2) + DAY_TICKS; - if (--_companies_ainew[c->index].idle == 0) { - // We are done idling.. what you say? Let's do something! - // I mean.. the next tick ;) - _companies_ainew[c->index].state = AI_STATE_WAKE_UP; - } -} - - -// This function picks out a task we are going to do. -// Currently supported: -// - Make new route -// - Check route -// - Build HQ -static void AiNew_State_WakeUp(Company *c) -{ - assert(_companies_ainew[c->index].state == AI_STATE_WAKE_UP); - // First, check if we have a HQ - if (c->location_of_HQ == INVALID_TILE) { - // We have no HQ yet, build one on a random place - // Random till we found a place for it! - // TODO: this should not be on a random place.. - AiNew_Build_CompanyHQ(c, AI_Random() % MapSize()); - // Enough for now, but we want to come back here the next time - // so we do not change any status - return; - } - - Money money = c->money - AI_MINIMUM_MONEY; - - // Let's pick an action! - if (_companies_ainew[c->index].action == AI_ACTION_NONE) { - int r = AI_Random() & 0xFF; - if (c->current_loan > 0 && - c->old_economy[1].income > AI_MINIMUM_INCOME_FOR_LOAN && - r < 10) { - _companies_ainew[c->index].action = AI_ACTION_REPAY_LOAN; - } else if (_companies_ainew[c->index].last_vehiclecheck_date + AI_DAYS_BETWEEN_VEHICLE_CHECKS < _date) { - // Check all vehicles once in a while - _companies_ainew[c->index].action = AI_ACTION_CHECK_ALL_VEHICLES; - _companies_ainew[c->index].last_vehiclecheck_date = _date; - } else if (r < 100 && !_settings_game.ai.ai_disable_veh_roadveh) { - // Do we have any spots for road-vehicles left open? - if (GetFreeUnitNumber(VEH_ROAD) <= _settings_game.vehicle.max_roadveh) { - if (r < 85) { - _companies_ainew[c->index].action = AI_ACTION_TRUCK_ROUTE; - } else { - _companies_ainew[c->index].action = AI_ACTION_BUS_ROUTE; - } - } -#if 0 - } else if (r < 200 && !_settings_game.ai.ai_disable_veh_train) { - if (GetFreeUnitNumber(VEH_TRAIN) <= _settings_game.vehicle.max_trains) { - _companies_ainew[c->index].action = AI_ACTION_TRAIN_ROUTE; - } -#endif - } - - _companies_ainew[c->index].counter = 0; - } - - if (_companies_ainew[c->index].counter++ > AI_MAX_TRIES_FOR_SAME_ROUTE) { - _companies_ainew[c->index].action = AI_ACTION_NONE; - return; - } - - if (_settings_game.ai.ai_disable_veh_roadveh && ( - _companies_ainew[c->index].action == AI_ACTION_BUS_ROUTE || - _companies_ainew[c->index].action == AI_ACTION_TRUCK_ROUTE - )) { - _companies_ainew[c->index].action = AI_ACTION_NONE; - return; - } - - if (_companies_ainew[c->index].action == AI_ACTION_REPAY_LOAN && - money > AI_MINIMUM_LOAN_REPAY_MONEY) { - // We start repaying some money.. - _companies_ainew[c->index].state = AI_STATE_REPAY_MONEY; - return; - } - - if (_companies_ainew[c->index].action == AI_ACTION_CHECK_ALL_VEHICLES) { - _companies_ainew[c->index].state = AI_STATE_CHECK_ALL_VEHICLES; - return; - } - - // It is useless to start finding a route if we don't have enough money - // to build the route anyway.. - if (_companies_ainew[c->index].action == AI_ACTION_BUS_ROUTE && - money > AI_MINIMUM_BUS_ROUTE_MONEY) { - if (GetFreeUnitNumber(VEH_ROAD) > _settings_game.vehicle.max_roadveh) { - _companies_ainew[c->index].action = AI_ACTION_NONE; - return; - } - _companies_ainew[c->index].cargo = AI_NEED_CARGO; - _companies_ainew[c->index].state = AI_STATE_LOCATE_ROUTE; - _companies_ainew[c->index].tbt = AI_BUS; // Bus-route - return; - } - if (_companies_ainew[c->index].action == AI_ACTION_TRUCK_ROUTE && - money > AI_MINIMUM_TRUCK_ROUTE_MONEY) { - if (GetFreeUnitNumber(VEH_ROAD) > _settings_game.vehicle.max_roadveh) { - _companies_ainew[c->index].action = AI_ACTION_NONE; - return; - } - _companies_ainew[c->index].cargo = AI_NEED_CARGO; - _companies_ainew[c->index].last_id = 0; - _companies_ainew[c->index].state = AI_STATE_LOCATE_ROUTE; - _companies_ainew[c->index].tbt = AI_TRUCK; - return; - } - - _companies_ainew[c->index].state = AI_STATE_NOTHING; -} - - -static void AiNew_State_ActionDone(Company *c) -{ - _companies_ainew[c->index].action = AI_ACTION_NONE; - _companies_ainew[c->index].state = AI_STATE_NOTHING; -} - - -// Check if a city or industry is good enough to start a route there -static bool AiNew_Check_City_or_Industry(Company *c, int ic, byte type) -{ - if (type == AI_CITY) { - const Town *t = GetTown(ic); - const Station *st; - uint count = 0; - int j = 0; - - // We don't like roadconstructions, don't even true such a city - if (t->road_build_months != 0) return false; - - // Check if the rating in a city is high enough - // If not, take a chance if we want to continue - if (t->ratings[_current_company] < 0 && AI_CHANCE16(1, 4)) return false; - - if (t->max_pass - t->act_pass < AI_CHECKCITY_NEEDED_CARGO && !AI_CHANCE16(1, AI_CHECKCITY_CITY_CHANCE)) return false; - - // Check if we have build a station in this town the last 6 months - // else we don't do it. This is done, because stat updates can be slow - // and sometimes it takes up to 4 months before the stats are corectly. - // This way we don't get 12 busstations in one city of 100 population ;) - FOR_ALL_STATIONS(st) { - // Do we own it? - if (st->owner == _current_company) { - // Are we talking busses? - if (_companies_ainew[c->index].tbt == AI_BUS && (FACIL_BUS_STOP & st->facilities) != FACIL_BUS_STOP) continue; - // Is it the same city as we are in now? - if (st->town != t) continue; - // When was this station build? - if (_date - st->build_date < AI_CHECKCITY_DATE_BETWEEN) return false; - // Cound the amount of stations in this city that we own - count++; - } else { - // We do not own it, request some info about the station - // we want to know if this station gets the same good. If so, - // we want to know its rating. If it is too high, we are not going - // to build there - if (!st->goods[CT_PASSENGERS].last_speed) continue; - // Is it around our city - if (DistanceManhattan(st->xy, t->xy) > 10) continue; - // It does take this cargo.. what is his rating? - if (st->goods[CT_PASSENGERS].rating < AI_CHECKCITY_CARGO_RATING) continue; - j++; - // When this is the first station, we build a second with no problem ;) - if (j == 1) continue; - // The rating is high.. second station... - // a little chance that we still continue - // But if there are 3 stations of this size, we never go on... - if (j == 2 && AI_CHANCE16(1, AI_CHECKCITY_CARGO_RATING_CHANCE)) continue; - // We don't like this station :( - return false; - } - } - - // We are about to add one... - count++; - // Check if we the city can provide enough cargo for this amount of stations.. - if (count * AI_CHECKCITY_CARGO_PER_STATION > t->max_pass) return false; - - // All check are okay, so we can build here! - return true; - } - if (type == AI_INDUSTRY) { - const Industry *i = GetIndustry(ic); - const Station *st; - int count = 0; - int j = 0; - - if (i->town != NULL && i->town->ratings[_current_company] < 0 && AI_CHANCE16(1, 4)) return false; - - // No limits on delevering stations! - // Or for industry that does not give anything yet - if (i->produced_cargo[0] == CT_INVALID || i->last_month_production[0] == 0) return true; - - if (i->last_month_production[0] - i->last_month_transported[0] < AI_CHECKCITY_NEEDED_CARGO) return false; - - // Check if we have build a station in this town the last 6 months - // else we don't do it. This is done, because stat updates can be slow - // and sometimes it takes up to 4 months before the stats are corectly. - FOR_ALL_STATIONS(st) { - // Do we own it? - if (st->owner == _current_company) { - // Are we talking trucks? - if (_companies_ainew[c->index].tbt == AI_TRUCK && (FACIL_TRUCK_STOP & st->facilities) != FACIL_TRUCK_STOP) continue; - // Is it the same city as we are in now? - if (st->town != i->town) continue; - // When was this station build? - if (_date - st->build_date < AI_CHECKCITY_DATE_BETWEEN) return false; - // Cound the amount of stations in this city that we own - count++; - } else { - // We do not own it, request some info about the station - // we want to know if this station gets the same good. If so, - // we want to know its rating. If it is too high, we are not going - // to build there - if (i->produced_cargo[0] == CT_INVALID) continue; - // It does not take this cargo - if (!st->goods[i->produced_cargo[0]].last_speed) continue; - // Is it around our industry - if (DistanceManhattan(st->xy, i->xy) > 5) continue; - // It does take this cargo.. what is his rating? - if (st->goods[i->produced_cargo[0]].rating < AI_CHECKCITY_CARGO_RATING) continue; - j++; - // The rating is high.. a little chance that we still continue - // But if there are 2 stations of this size, we never go on... - if (j == 1 && AI_CHANCE16(1, AI_CHECKCITY_CARGO_RATING_CHANCE)) continue; - // We don't like this station :( - return false; - } - } - - // We are about to add one... - count++; - // Check if we the city can provide enough cargo for this amount of stations.. - if (count * AI_CHECKCITY_CARGO_PER_STATION > i->last_month_production[0]) return false; - - // All check are okay, so we can build here! - return true; - } - - return true; -} - - -// This functions tries to locate a good route -static void AiNew_State_LocateRoute(Company *c) -{ - assert(_companies_ainew[c->index].state == AI_STATE_LOCATE_ROUTE); - // For now, we only support PASSENGERS, CITY and BUSSES - - // We don't have a route yet - if (_companies_ainew[c->index].cargo == AI_NEED_CARGO) { - _companies_ainew[c->index].new_cost = 0; // No cost yet - _companies_ainew[c->index].temp = -1; - // Reset the counter - _companies_ainew[c->index].counter = 0; - - _companies_ainew[c->index].from_ic = -1; - _companies_ainew[c->index].to_ic = -1; - if (_companies_ainew[c->index].tbt == AI_BUS) { - // For now we only have a passenger route - _companies_ainew[c->index].cargo = CT_PASSENGERS; - - // Find a route to cities - _companies_ainew[c->index].from_type = AI_CITY; - _companies_ainew[c->index].to_type = AI_CITY; - } else if (_companies_ainew[c->index].tbt == AI_TRUCK) { - _companies_ainew[c->index].cargo = AI_NO_CARGO; - - _companies_ainew[c->index].from_type = AI_INDUSTRY; - _companies_ainew[c->index].to_type = AI_INDUSTRY; - } - - // Now we are doing initing, we wait one tick - return; - } - - // Increase the counter and abort if it is taking too long! - _companies_ainew[c->index].counter++; - if (_companies_ainew[c->index].counter > AI_LOCATE_ROUTE_MAX_COUNTER) { - // Switch back to doing nothing! - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return; - } - - // We are going to locate a city from where we are going to connect - if (_companies_ainew[c->index].from_ic == -1) { - if (_companies_ainew[c->index].temp == -1) { - // First, we pick a random spot to search from - if (_companies_ainew[c->index].from_type == AI_CITY) { - _companies_ainew[c->index].temp = AI_RandomRange(GetMaxTownIndex() + 1); - } else { - _companies_ainew[c->index].temp = AI_RandomRange(GetMaxIndustryIndex() + 1); - } - } - - if (!AiNew_Check_City_or_Industry(c, _companies_ainew[c->index].temp, _companies_ainew[c->index].from_type)) { - // It was not a valid city - // increase the temp with one, and return. We will come back later here - // to try again - _companies_ainew[c->index].temp++; - if (_companies_ainew[c->index].from_type == AI_CITY) { - if (_companies_ainew[c->index].temp > GetMaxTownIndex()) _companies_ainew[c->index].temp = 0; - } else { - if (_companies_ainew[c->index].temp > GetMaxIndustryIndex()) _companies_ainew[c->index].temp = 0; - } - - // Don't do an attempt if we are trying the same id as the last time... - if (_companies_ainew[c->index].last_id == _companies_ainew[c->index].temp) return; - _companies_ainew[c->index].last_id = _companies_ainew[c->index].temp; - - return; - } - - // We found a good city/industry, save the data of it - _companies_ainew[c->index].from_ic = _companies_ainew[c->index].temp; - - // Start the next tick with finding a to-city - _companies_ainew[c->index].temp = -1; - return; - } - - // Find a to-city - if (_companies_ainew[c->index].temp == -1) { - // First, we pick a random spot to search to - if (_companies_ainew[c->index].to_type == AI_CITY) { - _companies_ainew[c->index].temp = AI_RandomRange(GetMaxTownIndex() + 1); - } else { - _companies_ainew[c->index].temp = AI_RandomRange(GetMaxIndustryIndex() + 1); - } - } - - // The same city is not allowed - // Also check if the city is valid - if (_companies_ainew[c->index].temp != _companies_ainew[c->index].from_ic && AiNew_Check_City_or_Industry(c, _companies_ainew[c->index].temp, _companies_ainew[c->index].to_type)) { - // Maybe it is valid.. - - /* We need to know if they are not to far apart from eachother.. - * We do that by checking how much cargo we have to move and how long the - * route is. - */ - - if (_companies_ainew[c->index].from_type == AI_CITY && _companies_ainew[c->index].tbt == AI_BUS) { - const Town *town_from = GetTown(_companies_ainew[c->index].from_ic); - const Town *town_temp = GetTown(_companies_ainew[c->index].temp); - uint distance = DistanceManhattan(town_from->xy, town_temp->xy); - int max_cargo; - - max_cargo = town_from->max_pass + town_temp->max_pass; - max_cargo -= town_from->act_pass + town_temp->act_pass; - - // max_cargo is now the amount of cargo we can move between the two cities - // If it is more than the distance, we allow it - if (distance <= max_cargo * AI_LOCATEROUTE_BUS_CARGO_DISTANCE) { - // We found a good city/industry, save the data of it - _companies_ainew[c->index].to_ic = _companies_ainew[c->index].temp; - _companies_ainew[c->index].state = AI_STATE_FIND_STATION; - - DEBUG(ai, 1, "[LocateRoute] found bus-route of %d tiles long (from %d to %d)", - distance, - _companies_ainew[c->index].from_ic, - _companies_ainew[c->index].temp - ); - - _companies_ainew[c->index].from_tile = 0; - _companies_ainew[c->index].to_tile = 0; - - return; - } - } else if (_companies_ainew[c->index].tbt == AI_TRUCK) { - const Industry *ind_from = GetIndustry(_companies_ainew[c->index].from_ic); - const Industry *ind_temp = GetIndustry(_companies_ainew[c->index].temp); - bool found = false; - int max_cargo = 0; - uint i; - - // TODO: in max_cargo, also check other cargo (beside [0]) - // First we check if the from_ic produces cargo that this ic accepts - if (ind_from->produced_cargo[0] != CT_INVALID && ind_from->last_month_production[0] != 0) { - for (i = 0; i < lengthof(ind_temp->accepts_cargo); i++) { - if (ind_temp->accepts_cargo[i] == CT_INVALID) break; - if (ind_from->produced_cargo[0] == ind_temp->accepts_cargo[i]) { - // Found a compatible industry - max_cargo = ind_from->last_month_production[0] - ind_from->last_month_transported[0]; - found = true; - _companies_ainew[c->index].from_deliver = true; - _companies_ainew[c->index].to_deliver = false; - break; - } - } - } - if (!found && ind_temp->produced_cargo[0] != CT_INVALID && ind_temp->last_month_production[0] != 0) { - // If not check if the current ic produces cargo that the from_ic accepts - for (i = 0; i < lengthof(ind_from->accepts_cargo); i++) { - if (ind_from->accepts_cargo[i] == CT_INVALID) break; - if (ind_from->produced_cargo[0] == ind_from->accepts_cargo[i]) { - // Found a compatbiel industry - found = true; - max_cargo = ind_temp->last_month_production[0] - ind_temp->last_month_transported[0]; - _companies_ainew[c->index].from_deliver = false; - _companies_ainew[c->index].to_deliver = true; - break; - } - } - } - if (found) { - // Yeah, they are compatible!!! - // Check the length against the amount of goods - uint distance = DistanceManhattan(ind_from->xy, ind_temp->xy); - - if (distance > AI_LOCATEROUTE_TRUCK_MIN_DISTANCE && - distance <= max_cargo * AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE) { - _companies_ainew[c->index].to_ic = _companies_ainew[c->index].temp; - if (_companies_ainew[c->index].from_deliver) { - _companies_ainew[c->index].cargo = ind_from->produced_cargo[0]; - } else { - _companies_ainew[c->index].cargo = ind_temp->produced_cargo[0]; - } - _companies_ainew[c->index].state = AI_STATE_FIND_STATION; - - DEBUG(ai, 1, "[LocateRoute] found truck-route of %d tiles long (from %d to %d)", - distance, - _companies_ainew[c->index].from_ic, - _companies_ainew[c->index].temp - ); - - _companies_ainew[c->index].from_tile = 0; - _companies_ainew[c->index].to_tile = 0; - - return; - } - } - } - } - - // It was not a valid city - // increase the temp with one, and return. We will come back later here - // to try again - _companies_ainew[c->index].temp++; - if (_companies_ainew[c->index].to_type == AI_CITY) { - if (_companies_ainew[c->index].temp > GetMaxTownIndex()) _companies_ainew[c->index].temp = 0; - } else { - if (_companies_ainew[c->index].temp > GetMaxIndustryIndex()) _companies_ainew[c->index].temp = 0; - } - - // Don't do an attempt if we are trying the same id as the last time... - if (_companies_ainew[c->index].last_id == _companies_ainew[c->index].temp) return; - _companies_ainew[c->index].last_id = _companies_ainew[c->index].temp; -} - - -// Check if there are not more than a certain amount of vehicles pointed to a certain -// station. This to prevent 10 busses going to one station, which gives... problems ;) -static bool AiNew_CheckVehicleStation(Company *c, Station *st) -{ - int count = 0; - Vehicle *v; - - // Also check if we don't have already a lot of busses to this city... - FOR_ALL_VEHICLES(v) { - if (v->owner == _current_company) { - const Order *order; - - FOR_VEHICLE_ORDERS(v, order) { - if (order->IsType(OT_GOTO_STATION) && GetStation(order->GetDestination()) == st) { - // This vehicle has this city in its list - count++; - } - } - } - } - - if (count > AI_CHECK_MAX_VEHICLE_PER_STATION) return false; - return true; -} - -// This function finds a good spot for a station -static void AiNew_State_FindStation(Company *c) -{ - TileIndex tile; - Station *st; - int count = 0; - EngineID i; - TileIndex new_tile = 0; - DiagDirection direction = DIAGDIR_NE; - Town *town = NULL; - assert(_companies_ainew[c->index].state == AI_STATE_FIND_STATION); - - if (_companies_ainew[c->index].from_tile == 0) { - // First we scan for a station in the from-city - if (_companies_ainew[c->index].from_type == AI_CITY) { - town = GetTown(_companies_ainew[c->index].from_ic); - tile = town->xy; - } else { - tile = GetIndustry(_companies_ainew[c->index].from_ic)->xy; - } - } else if (_companies_ainew[c->index].to_tile == 0) { - // Second we scan for a station in the to-city - if (_companies_ainew[c->index].to_type == AI_CITY) { - town = GetTown(_companies_ainew[c->index].to_ic); - tile = town->xy; - } else { - tile = GetIndustry(_companies_ainew[c->index].to_ic)->xy; - } - } else { - // Unsupported request - // Go to FIND_PATH - _companies_ainew[c->index].temp = -1; - _companies_ainew[c->index].state = AI_STATE_FIND_PATH; - return; - } - - // First, we are going to look at the stations that already exist inside the city - // If there is enough cargo left in the station, we take that station - // If that is not possible, and there are more than 2 stations in the city, abort - i = AiNew_PickVehicle(c); - // Euhmz, this should not happen _EVER_ - // Quit finding a route... - if (i == INVALID_ENGINE) { - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return; - } - - FOR_ALL_STATIONS(st) { - if (st->owner == _current_company) { - if (_companies_ainew[c->index].tbt == AI_BUS && (FACIL_BUS_STOP & st->facilities) == FACIL_BUS_STOP) { - if (st->town == town) { - // Check how much cargo there is left in the station - if ((int)st->goods[_companies_ainew[c->index].cargo].cargo.Count() > RoadVehInfo(i)->capacity * AI_STATION_REUSE_MULTIPLER) { - if (AiNew_CheckVehicleStation(c, st)) { - // We did found a station that was good enough! - new_tile = st->xy; - direction = GetRoadStopDir(st->xy); - break; - } - } - count++; - } - } - } - } - // We are going to add a new station... - if (new_tile == 0) count++; - // No more than 2 stations allowed in a city - // This is because only the best 2 stations of one cargo do get any cargo - if (count > 2) { - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return; - } - - if (new_tile == 0 && _companies_ainew[c->index].tbt == AI_BUS) { - uint x, y, i = 0; - CommandCost r; - uint best; - uint accepts[NUM_CARGO]; - TileIndex found_spot[AI_FINDSTATION_TILE_RANGE*AI_FINDSTATION_TILE_RANGE * 4]; - uint found_best[AI_FINDSTATION_TILE_RANGE*AI_FINDSTATION_TILE_RANGE * 4]; - // To find a good spot we scan a range from the center, a get the point - // where we get the most cargo and where it is buildable. - // TODO: also check for station of myself and make sure we are not - // taking eachothers passengers away (bad result when it does not) - for (x = TileX(tile) - AI_FINDSTATION_TILE_RANGE; x <= TileX(tile) + AI_FINDSTATION_TILE_RANGE; x++) { - for (y = TileY(tile) - AI_FINDSTATION_TILE_RANGE; y <= TileY(tile) + AI_FINDSTATION_TILE_RANGE; y++) { - new_tile = TileXY(x, y); - if (IsTileType(new_tile, MP_CLEAR) || IsTileType(new_tile, MP_TREES)) { - // This tile we can build on! - // Check acceptance - // XXX - Get the catchment area - GetAcceptanceAroundTiles(accepts, new_tile, 1, 1, 4); - // >> 3 == 0 means no cargo - if (accepts[_companies_ainew[c->index].cargo] >> 3 == 0) continue; - // See if we can build the station - r = AiNew_Build_Station(c, _companies_ainew[c->index].tbt, new_tile, 0, 0, 0, DC_QUERY_COST); - if (CmdFailed(r)) continue; - // We can build it, so add it to found_spot - found_spot[i] = new_tile; - found_best[i++] = accepts[_companies_ainew[c->index].cargo]; - } - } - } - - // If i is still zero, we did not find anything - if (i == 0) { - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return; - } - - // Go through all the found_best and check which has the highest value - best = 0; - new_tile = 0; - - for (x = 0; x < i; x++) { - if (found_best[x] > best || - (found_best[x] == best && DistanceManhattan(tile, new_tile) > DistanceManhattan(tile, found_spot[x]))) { - new_tile = found_spot[x]; - best = found_best[x]; - } - } - - // See how much it is going to cost us... - r = AiNew_Build_Station(c, _companies_ainew[c->index].tbt, new_tile, 0, 0, 0, DC_QUERY_COST); - _companies_ainew[c->index].new_cost += r.GetCost(); - - direction = (DiagDirection)AI_PATHFINDER_NO_DIRECTION; - } else if (new_tile == 0 && _companies_ainew[c->index].tbt == AI_TRUCK) { - // Truck station locater works differently.. a station can be on any place - // as long as it is in range. So we give back code AI_STATION_RANGE - // so the pathfinder routine can work it out! - new_tile = AI_STATION_RANGE; - direction = (DiagDirection)AI_PATHFINDER_NO_DIRECTION; - } - - if (_companies_ainew[c->index].from_tile == 0) { - _companies_ainew[c->index].from_tile = new_tile; - _companies_ainew[c->index].from_direction = direction; - // Now we found thisone, go in for to_tile - return; - } else if (_companies_ainew[c->index].to_tile == 0) { - _companies_ainew[c->index].to_tile = new_tile; - _companies_ainew[c->index].to_direction = direction; - // K, done placing stations! - _companies_ainew[c->index].temp = -1; - _companies_ainew[c->index].state = AI_STATE_FIND_PATH; - return; - } -} - - -// We try to find a path between 2 points -static void AiNew_State_FindPath(Company *c) -{ - int r; - assert(_companies_ainew[c->index].state == AI_STATE_FIND_PATH); - - // First time, init some data - if (_companies_ainew[c->index].temp == -1) { - // Init path_info - if (_companies_ainew[c->index].from_tile == AI_STATION_RANGE) { - const Industry *i = GetIndustry(_companies_ainew[c->index].from_ic); - - // For truck routes we take a range around the industry - _companies_ainew[c->index].path_info.start_tile_tl = i->xy - TileDiffXY(1, 1); - _companies_ainew[c->index].path_info.start_tile_br = i->xy + TileDiffXY(i->width + 1, i->height + 1); - _companies_ainew[c->index].path_info.start_direction = _companies_ainew[c->index].from_direction; - } else { - _companies_ainew[c->index].path_info.start_tile_tl = _companies_ainew[c->index].from_tile; - _companies_ainew[c->index].path_info.start_tile_br = _companies_ainew[c->index].from_tile; - _companies_ainew[c->index].path_info.start_direction = _companies_ainew[c->index].from_direction; - } - - if (_companies_ainew[c->index].to_tile == AI_STATION_RANGE) { - const Industry *i = GetIndustry(_companies_ainew[c->index].to_ic); - - _companies_ainew[c->index].path_info.end_tile_tl = i->xy - TileDiffXY(1, 1); - _companies_ainew[c->index].path_info.end_tile_br = i->xy + TileDiffXY(i->width + 1, i->height + 1); - _companies_ainew[c->index].path_info.end_direction = _companies_ainew[c->index].to_direction; - } else { - _companies_ainew[c->index].path_info.end_tile_tl = _companies_ainew[c->index].to_tile; - _companies_ainew[c->index].path_info.end_tile_br = _companies_ainew[c->index].to_tile; - _companies_ainew[c->index].path_info.end_direction = _companies_ainew[c->index].to_direction; - } - - _companies_ainew[c->index].path_info.rail_or_road = (_companies_ainew[c->index].tbt == AI_TRAIN); - - // First, clean the pathfinder with our new begin and endpoints - clean_AyStar_AiPathFinder(_companies_ainew[c->index].pathfinder, &_companies_ainew[c->index].path_info); - - _companies_ainew[c->index].temp = 0; - } - - // Start the pathfinder - r = _companies_ainew[c->index].pathfinder->main(_companies_ainew[c->index].pathfinder); - switch (r) { - case AYSTAR_NO_PATH: - DEBUG(ai, 1, "No route found by pathfinder"); - // Start all over again - _companies_ainew[c->index].state = AI_STATE_NOTHING; - break; - - case AYSTAR_FOUND_END_NODE: // We found the end-point - _companies_ainew[c->index].temp = -1; - _companies_ainew[c->index].state = AI_STATE_FIND_DEPOT; - break; - - // In any other case, we are still busy finding the route - default: break; - } -} - - -// This function tries to locate a good place for a depot! -static void AiNew_State_FindDepot(Company *c) -{ - // To place the depot, we walk through the route, and if we find a lovely spot (MP_CLEAR, MP_TREES), we place it there.. - // Simple, easy, works! - // To make the depot stand in the middle of the route, we start from the center.. - // But first we walk through the route see if we can find a depot that is ours - // this keeps things nice ;) - int g, i; - CommandCost r; - DiagDirection j; - TileIndex tile; - assert(_companies_ainew[c->index].state == AI_STATE_FIND_DEPOT); - - _companies_ainew[c->index].depot_tile = 0; - - for (i = 2; i < _companies_ainew[c->index].path_info.route_length - 2; i++) { - tile = _companies_ainew[c->index].path_info.route[i]; - for (j = DIAGDIR_BEGIN; j < DIAGDIR_END; j++) { - TileIndex t = tile + TileOffsByDiagDir(j); - - if (IsRoadDepotTile(t) && - IsTileOwner(t, _current_company) && - GetRoadDepotDirection(t) == ReverseDiagDir(j)) { - _companies_ainew[c->index].depot_tile = t; - _companies_ainew[c->index].depot_direction = ReverseDiagDir(j); - _companies_ainew[c->index].state = AI_STATE_VERIFY_ROUTE; - return; - } - } - } - - // This routine let depot finding start in the middle, and work his way to the stations - // It makes depot placing nicer :) - i = _companies_ainew[c->index].path_info.route_length / 2; - g = 1; - while (i > 1 && i < _companies_ainew[c->index].path_info.route_length - 2) { - i += g; - g *= -1; - (g < 0 ? g-- : g++); - - if (_companies_ainew[c->index].path_info.route_extra[i] != 0 || _companies_ainew[c->index].path_info.route_extra[i + 1] != 0) { - // Bridge or tunnel.. we can't place a depot there - continue; - } - - tile = _companies_ainew[c->index].path_info.route[i]; - - for (j = DIAGDIR_BEGIN; j < DIAGDIR_END; j++) { - TileIndex t = tile + TileOffsByDiagDir(j); - - // It may not be placed on the road/rail itself - // And because it is not build yet, we can't see it on the tile.. - // So check the surrounding tiles :) - if (t == _companies_ainew[c->index].path_info.route[i - 1] || - t == _companies_ainew[c->index].path_info.route[i + 1]) { - continue; - } - // Not around a bridge? - if (_companies_ainew[c->index].path_info.route_extra[i] != 0) continue; - if (IsTileType(tile, MP_TUNNELBRIDGE)) continue; - // Is the terrain clear? - if (IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES)) { - // If the current tile is on a slope then we do not allow this - if (GetTileSlope(tile, NULL) != SLOPE_FLAT) continue; - // Check if everything went okay.. - r = AiNew_Build_Depot(c, t, ReverseDiagDir(j), 0); - if (CmdFailed(r)) continue; - // Found a spot! - _companies_ainew[c->index].new_cost += r.GetCost(); - _companies_ainew[c->index].depot_tile = t; - _companies_ainew[c->index].depot_direction = ReverseDiagDir(j); // Reverse direction - _companies_ainew[c->index].state = AI_STATE_VERIFY_ROUTE; - return; - } - } - } - - // Failed to find a depot? - _companies_ainew[c->index].state = AI_STATE_NOTHING; -} - - -// This function calculates how many vehicles there are needed on this -// traject. -// It works pretty simple: get the length, see how much we move around -// and hussle that, and you know how many vehicles there are needed. -// It returns the cost for the vehicles -static int AiNew_HowManyVehicles(Company *c) -{ - if (_companies_ainew[c->index].tbt == AI_BUS) { - // For bus-routes we look at the time before we are back in the station - EngineID i; - int length, tiles_a_day; - int amount; - i = AiNew_PickVehicle(c); - if (i == INVALID_ENGINE) return 0; - // Passenger run.. how long is the route? - length = _companies_ainew[c->index].path_info.route_length; - // Calculating tiles a day a vehicle moves is not easy.. this is how it must be done! - tiles_a_day = RoadVehInfo(i)->max_speed * DAY_TICKS / 256 / 16; - if (tiles_a_day == 0) tiles_a_day = 1; - // We want a vehicle in a station once a month at least, so, calculate it! - // (the * 2 is because we have 2 stations ;)) - amount = length * 2 * 2 / tiles_a_day / 30; - if (amount == 0) amount = 1; - return amount; - } else if (_companies_ainew[c->index].tbt == AI_TRUCK) { - // For truck-routes we look at the cargo - EngineID i; - int length, amount, tiles_a_day; - int max_cargo; - i = AiNew_PickVehicle(c); - if (i == INVALID_ENGINE) return 0; - // Passenger run.. how long is the route? - length = _companies_ainew[c->index].path_info.route_length; - // Calculating tiles a day a vehicle moves is not easy.. this is how it must be done! - tiles_a_day = RoadVehInfo(i)->max_speed * DAY_TICKS / 256 / 16; - if (tiles_a_day == 0) tiles_a_day = 1; - if (_companies_ainew[c->index].from_deliver) { - max_cargo = GetIndustry(_companies_ainew[c->index].from_ic)->last_month_production[0]; - } else { - max_cargo = GetIndustry(_companies_ainew[c->index].to_ic)->last_month_production[0]; - } - - // This is because moving 60% is more than we can dream of! - max_cargo *= 6; - max_cargo /= 10; - // We want all the cargo to be gone in a month.. so, we know the cargo it delivers - // we know what the vehicle takes with him, and we know the time it takes him - // to get back here.. now let's do some math! - amount = 2 * length * max_cargo / tiles_a_day / 30 / RoadVehInfo(i)->capacity; - amount += 1; - return amount; - } else { - // Currently not supported - return 0; - } -} - - -// This function checks: -// - If the route went okay -// - Calculates the amount of money needed to build the route -// - Calculates how much vehicles needed for the route -static void AiNew_State_VerifyRoute(Company *c) -{ - int res, i; - assert(_companies_ainew[c->index].state == AI_STATE_VERIFY_ROUTE); - - // Let's calculate the cost of the path.. - // new_cost already contains the cost of the stations - _companies_ainew[c->index].path_info.position = -1; - - do { - _companies_ainew[c->index].path_info.position++; - _companies_ainew[c->index].new_cost += AiNew_Build_RoutePart(c, &_companies_ainew[c->index].path_info, DC_QUERY_COST).GetCost(); - } while (_companies_ainew[c->index].path_info.position != -2); - - // Now we know the price of build station + path. Now check how many vehicles - // we need and what the price for that will be - res = AiNew_HowManyVehicles(c); - // If res == 0, no vehicle was found, or an other problem did occour - if (res == 0) { - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return; - } - _companies_ainew[c->index].amount_veh = res; - _companies_ainew[c->index].cur_veh = 0; - - // Check how much it it going to cost us.. - for (i = 0; i < res; i++) { - _companies_ainew[c->index].new_cost += AiNew_Build_Vehicle(c, 0, DC_QUERY_COST).GetCost(); - } - - // Now we know how much the route is going to cost us - // Check if we have enough money for it! - if (_companies_ainew[c->index].new_cost > c->money - AI_MINIMUM_MONEY) { - // Too bad.. - DEBUG(ai, 1, "Insufficient funds to build route (%" OTTD_PRINTF64 "d)", (int64)_companies_ainew[c->index].new_cost); - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return; - } - - // Now we can build the route, check the direction of the stations! - if (_companies_ainew[c->index].from_direction == AI_PATHFINDER_NO_DIRECTION) { - _companies_ainew[c->index].from_direction = AiNew_GetDirection(_companies_ainew[c->index].path_info.route[_companies_ainew[c->index].path_info.route_length - 1], _companies_ainew[c->index].path_info.route[_companies_ainew[c->index].path_info.route_length - 2]); - } - if (_companies_ainew[c->index].to_direction == AI_PATHFINDER_NO_DIRECTION) { - _companies_ainew[c->index].to_direction = AiNew_GetDirection(_companies_ainew[c->index].path_info.route[0], _companies_ainew[c->index].path_info.route[1]); - } - if (_companies_ainew[c->index].from_tile == AI_STATION_RANGE) - _companies_ainew[c->index].from_tile = _companies_ainew[c->index].path_info.route[_companies_ainew[c->index].path_info.route_length - 1]; - if (_companies_ainew[c->index].to_tile == AI_STATION_RANGE) - _companies_ainew[c->index].to_tile = _companies_ainew[c->index].path_info.route[0]; - - _companies_ainew[c->index].state = AI_STATE_BUILD_STATION; - _companies_ainew[c->index].temp = 0; - - DEBUG(ai, 1, "The route is set and buildable, building 0x%X to 0x%X...", _companies_ainew[c->index].from_tile, _companies_ainew[c->index].to_tile); -} - - -// Build the stations -static void AiNew_State_BuildStation(Company *c) -{ - CommandCost res; - assert(_companies_ainew[c->index].state == AI_STATE_BUILD_STATION); - if (_companies_ainew[c->index].temp == 0) { - if (!IsTileType(_companies_ainew[c->index].from_tile, MP_STATION)) - res = AiNew_Build_Station(c, _companies_ainew[c->index].tbt, _companies_ainew[c->index].from_tile, 0, 0, _companies_ainew[c->index].from_direction, DC_EXEC); - } else { - if (!IsTileType(_companies_ainew[c->index].to_tile, MP_STATION)) - res = AiNew_Build_Station(c, _companies_ainew[c->index].tbt, _companies_ainew[c->index].to_tile, 0, 0, _companies_ainew[c->index].to_direction, DC_EXEC); - _companies_ainew[c->index].state = AI_STATE_BUILD_PATH; - } - if (CmdFailed(res)) { - DEBUG(ai, 0, "[BuildStation] station could not be built (0x%X)", _companies_ainew[c->index].to_tile); - _companies_ainew[c->index].state = AI_STATE_NOTHING; - // If the first station _was_ build, destroy it - if (_companies_ainew[c->index].temp != 0) - AI_DoCommand(_companies_ainew[c->index].from_tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR); - return; - } - _companies_ainew[c->index].temp++; -} - - -// Build the path -static void AiNew_State_BuildPath(Company *c) -{ - assert(_companies_ainew[c->index].state == AI_STATE_BUILD_PATH); - // _companies_ainew[c->index].temp is set to -1 when this function is called for the first time - if (_companies_ainew[c->index].temp == -1) { - DEBUG(ai, 1, "Starting to build new path"); - // Init the counter - _companies_ainew[c->index].counter = (4 - _settings_game.difficulty.competitor_speed) * AI_BUILDPATH_PAUSE + 1; - // Set the position to the startingplace (-1 because in a minute we do ++) - _companies_ainew[c->index].path_info.position = -1; - // And don't do this again - _companies_ainew[c->index].temp = 0; - } - // Building goes very fast on normal rate, so we are going to slow it down.. - // By let the counter count from AI_BUILDPATH_PAUSE to 0, we have a nice way :) - if (--_companies_ainew[c->index].counter != 0) return; - _companies_ainew[c->index].counter = (4 - _settings_game.difficulty.competitor_speed) * AI_BUILDPATH_PAUSE + 1; - - // Increase the building position - _companies_ainew[c->index].path_info.position++; - // Build route - AiNew_Build_RoutePart(c, &_companies_ainew[c->index].path_info, DC_EXEC); - if (_companies_ainew[c->index].path_info.position == -2) { - // This means we are done building! - - if (_companies_ainew[c->index].tbt == AI_TRUCK && !_settings_game.pf.roadveh_queue) { - // If they not queue, they have to go up and down to try again at a station... - // We don't want that, so try building some road left or right of the station - DiagDirection dir1, dir2, dir3; - TileIndex tile; - CommandCost ret; - for (int i = 0; i < 2; i++) { - if (i == 0) { - tile = _companies_ainew[c->index].from_tile + TileOffsByDiagDir(_companies_ainew[c->index].from_direction); - dir1 = ChangeDiagDir(_companies_ainew[c->index].from_direction, DIAGDIRDIFF_90LEFT); - dir2 = ChangeDiagDir(_companies_ainew[c->index].from_direction, DIAGDIRDIFF_90RIGHT); - dir3 = _companies_ainew[c->index].from_direction; - } else { - tile = _companies_ainew[c->index].to_tile + TileOffsByDiagDir(_companies_ainew[c->index].to_direction); - dir1 = ChangeDiagDir(_companies_ainew[c->index].to_direction, DIAGDIRDIFF_90LEFT); - dir2 = ChangeDiagDir(_companies_ainew[c->index].to_direction, DIAGDIRDIFF_90RIGHT); - dir3 = _companies_ainew[c->index].to_direction; - } - - ret = AI_DoCommand(tile, DiagDirToRoadBits(ReverseDiagDir(dir1)), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); - if (CmdSucceeded(ret)) { - TileIndexDiff offset = TileOffsByDiagDir(dir1); - if (IsTileType(tile + offset, MP_CLEAR) || IsTileType(tile + offset, MP_TREES)) { - ret = AI_DoCommand(tile + offset, AiNew_GetRoadDirection(tile, tile + offset, tile + offset + offset), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); - if (CmdSucceeded(ret)) { - if (IsTileType(tile + offset + offset, MP_CLEAR) || IsTileType(tile + offset + offset, MP_TREES)) - AI_DoCommand(tile + offset + offset, AiNew_GetRoadDirection(tile + offset, tile + offset + offset, tile + offset + offset + offset), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); - } - } - } - - ret = AI_DoCommand(tile, DiagDirToRoadBits(ReverseDiagDir(dir2)), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); - if (CmdSucceeded(ret)) { - TileIndexDiff offset = TileOffsByDiagDir(dir2); - if (IsTileType(tile + offset, MP_CLEAR) || IsTileType(tile + offset, MP_TREES)) { - ret = AI_DoCommand(tile + offset, AiNew_GetRoadDirection(tile, tile + offset, tile + offset + offset), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); - if (CmdSucceeded(ret)) { - if (IsTileType(tile + offset + offset, MP_CLEAR) || IsTileType(tile + offset + offset, MP_TREES)) - AI_DoCommand(tile + offset + offset, AiNew_GetRoadDirection(tile + offset, tile + offset + offset, tile + offset + offset + offset), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); - } - } - } - - ret = AI_DoCommand(tile, DiagDirToRoadBits(dir3), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); - if (CmdSucceeded(ret)) { - TileIndexDiff offset = TileOffsByDiagDir(dir3); - if (IsTileType(tile + offset, MP_CLEAR) || IsTileType(tile + offset, MP_TREES)) { - ret = AI_DoCommand(tile + offset, AiNew_GetRoadDirection(tile, tile + offset, tile + offset + offset), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); - if (CmdSucceeded(ret)) { - if (IsTileType(tile + offset + offset, MP_CLEAR) || IsTileType(tile + offset + offset, MP_TREES)) - AI_DoCommand(tile + offset + offset, AiNew_GetRoadDirection(tile + offset, tile + offset + offset, tile + offset + offset + offset), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); - } - } - } - } - } - - DEBUG(ai, 1, "Finished building path, cost: %" OTTD_PRINTF64 "d", (int64)_companies_ainew[c->index].new_cost); - _companies_ainew[c->index].state = AI_STATE_BUILD_DEPOT; - } -} - - -// Builds the depot -static void AiNew_State_BuildDepot(Company *c) -{ - CommandCost res; - assert(_companies_ainew[c->index].state == AI_STATE_BUILD_DEPOT); - - if (IsRoadDepotTile(_companies_ainew[c->index].depot_tile)) { - if (IsTileOwner(_companies_ainew[c->index].depot_tile, _current_company)) { - // The depot is already built - _companies_ainew[c->index].state = AI_STATE_BUILD_VEHICLE; - return; - } else { - // There is a depot, but not of our team! :( - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return; - } - } - - // There is a bus on the tile we want to build road on... idle till he is gone! (BAD PERSON! :p) - if (!EnsureNoVehicleOnGround(_companies_ainew[c->index].depot_tile + TileOffsByDiagDir(_companies_ainew[c->index].depot_direction))) - return; - - res = AiNew_Build_Depot(c, _companies_ainew[c->index].depot_tile, _companies_ainew[c->index].depot_direction, DC_EXEC); - if (CmdFailed(res)) { - DEBUG(ai, 0, "[BuildDepot] depot could not be built (0x%X)", _companies_ainew[c->index].depot_tile); - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return; - } - - _companies_ainew[c->index].state = AI_STATE_BUILD_VEHICLE; - _companies_ainew[c->index].idle = 10; - _companies_ainew[c->index].veh_main_id = INVALID_VEHICLE; -} - - -// Build vehicles -static void AiNew_State_BuildVehicle(Company *c) -{ - CommandCost res; - assert(_companies_ainew[c->index].state == AI_STATE_BUILD_VEHICLE); - - // Check if we need to build a vehicle - if (_companies_ainew[c->index].amount_veh == 0) { - // Nope, we are done! - // This means: we are all done! The route is open.. go back to NOTHING - // He will idle some time and it will all start over again.. :) - _companies_ainew[c->index].state = AI_STATE_ACTION_DONE; - return; - } - if (--_companies_ainew[c->index].idle != 0) return; - // It is realistic that the AI can only build 1 vehicle a day.. - // This makes sure of that! - _companies_ainew[c->index].idle = AI_BUILD_VEHICLE_TIME_BETWEEN; - - // Build the vehicle - res = AiNew_Build_Vehicle(c, _companies_ainew[c->index].depot_tile, DC_EXEC); - if (CmdFailed(res)) { - // This happens when the AI can't build any more vehicles! - _companies_ainew[c->index].state = AI_STATE_NOTHING; - return; - } - // Increase the current counter - _companies_ainew[c->index].cur_veh++; - // Decrease the total counter - _companies_ainew[c->index].amount_veh--; - // Go give some orders! - _companies_ainew[c->index].state = AI_STATE_WAIT_FOR_BUILD; -} - - -// Put the stations in the order list -static void AiNew_State_GiveOrders(Company *c) -{ - int idx; - Order order; - - assert(_companies_ainew[c->index].state == AI_STATE_GIVE_ORDERS); - - if (_companies_ainew[c->index].veh_main_id != INVALID_VEHICLE) { - AI_DoCommand(0, _companies_ainew[c->index].veh_id + (_companies_ainew[c->index].veh_main_id << 16), CO_SHARE, DC_EXEC, CMD_CLONE_ORDER); - - _companies_ainew[c->index].state = AI_STATE_START_VEHICLE; - return; - } else { - _companies_ainew[c->index].veh_main_id = _companies_ainew[c->index].veh_id; - } - - // Very handy for AI, goto depot.. but yeah, it needs to be activated ;) - if (_settings_game.order.gotodepot) { - idx = 0; - order.MakeGoToDepot(GetDepotByTile(_companies_ainew[c->index].depot_tile)->index, ODTFB_PART_OF_ORDERS); - AI_DoCommand(0, _companies_ainew[c->index].veh_id + (idx << 16), order.Pack(), DC_EXEC, CMD_INSERT_ORDER); - } - - idx = 0; - order.MakeGoToStation(GetStationIndex(_companies_ainew[c->index].to_tile)); - if (_companies_ainew[c->index].tbt == AI_TRUCK && _companies_ainew[c->index].to_deliver) order.SetLoadType(OLFB_FULL_LOAD); - AI_DoCommand(0, _companies_ainew[c->index].veh_id + (idx << 16), order.Pack(), DC_EXEC, CMD_INSERT_ORDER); - - idx = 0; - order.MakeGoToStation(GetStationIndex(_companies_ainew[c->index].from_tile)); - if (_companies_ainew[c->index].tbt == AI_TRUCK && _companies_ainew[c->index].from_deliver) order.SetLoadType(OLFB_FULL_LOAD); - AI_DoCommand(0, _companies_ainew[c->index].veh_id + (idx << 16), order.Pack(), DC_EXEC, CMD_INSERT_ORDER); - - // Start the engines! - _companies_ainew[c->index].state = AI_STATE_START_VEHICLE; -} - - -// Start the vehicle -static void AiNew_State_StartVehicle(Company *c) -{ - assert(_companies_ainew[c->index].state == AI_STATE_START_VEHICLE); - - // Skip the first order if it is a second vehicle - // This to make vehicles go different ways.. - if (_companies_ainew[c->index].cur_veh & 1) - AI_DoCommand(0, _companies_ainew[c->index].veh_id, 1, DC_EXEC, CMD_SKIP_TO_ORDER); - - // 3, 2, 1... go! (give START_STOP command ;)) - AI_DoCommand(0, _companies_ainew[c->index].veh_id, 0, DC_EXEC, CMD_START_STOP_VEHICLE); - // Try to build an other vehicle (that function will stop building when needed) - _companies_ainew[c->index].idle = 10; - _companies_ainew[c->index].state = AI_STATE_BUILD_VEHICLE; -} - - -// Repays money -static void AiNew_State_RepayMoney(Company *c) -{ - uint i; - - for (i = 0; i < AI_LOAN_REPAY; i++) { - AI_DoCommand(0, 0, 0, DC_EXEC, CMD_DECREASE_LOAN); - } - _companies_ainew[c->index].state = AI_STATE_ACTION_DONE; -} - - -static void AiNew_CheckVehicle(Company *c, Vehicle *v) -{ - // When a vehicle is under the 6 months, we don't check for anything - if (v->age < 180) return; - - // When a vehicle is older than 1 year, it should make money... - if (v->age > 360) { - // If both years together are not more than AI_MINIMUM_ROUTE_PROFIT, - // it is not worth the line I guess... - if (v->profit_last_year + v->profit_this_year < (Money)256 * AI_MINIMUM_ROUTE_PROFIT || - (v->reliability * 100 >> 16) < 40) { - // There is a possibility that the route is fucked up... - if (v->cargo.DaysInTransit() > AI_VEHICLE_LOST_DAYS) { - // The vehicle is lost.. check the route, or else, get the vehicle - // back to a depot - // TODO: make this piece of code - } - - - // We are already sending him back - if (AiNew_GetSpecialVehicleFlag(c, v) & AI_VEHICLEFLAG_SELL) { - if (v->type == VEH_ROAD && IsRoadDepotTile(v->tile) && - (v->vehstatus & VS_STOPPED)) { - // We are at the depot, sell the vehicle - AI_DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH); - } - return; - } - - if (!AiNew_SetSpecialVehicleFlag(c, v, AI_VEHICLEFLAG_SELL)) return; - { - CommandCost ret; - if (v->type == VEH_ROAD) - ret = AI_DoCommand(0, v->index, 0, DC_EXEC, CMD_SEND_ROADVEH_TO_DEPOT); - // This means we can not find a depot :s - // if (CmdFailed(ret)) - } - } - } -} - - -// Checks all vehicles if they are still valid and make money and stuff -static void AiNew_State_CheckAllVehicles(Company *c) -{ - Vehicle *v; - - FOR_ALL_VEHICLES(v) { - if (v->owner != c->index) continue; - // Currently, we only know how to handle road-vehicles - if (v->type != VEH_ROAD) continue; - - AiNew_CheckVehicle(c, v); - } - - _companies_ainew[c->index].state = AI_STATE_ACTION_DONE; -} - - -// Using the technique simular to the original AI -// Keeps things logical -// It really should be in the same order as the AI_STATE's are! -static AiNew_StateFunction * const _ainew_state[] = { - NULL, - AiNew_State_FirstTime, - AiNew_State_Nothing, - AiNew_State_WakeUp, - AiNew_State_LocateRoute, - AiNew_State_FindStation, - AiNew_State_FindPath, - AiNew_State_FindDepot, - AiNew_State_VerifyRoute, - AiNew_State_BuildStation, - AiNew_State_BuildPath, - AiNew_State_BuildDepot, - AiNew_State_BuildVehicle, - NULL, - AiNew_State_GiveOrders, - AiNew_State_StartVehicle, - AiNew_State_RepayMoney, - AiNew_State_CheckAllVehicles, - AiNew_State_ActionDone, - NULL, -}; - -static void AiNew_OnTick(Company *c) -{ - if (_ainew_state[_companies_ainew[c->index].state] != NULL) - _ainew_state[_companies_ainew[c->index].state](c); -} - - -void AiNewDoGameLoop(Company *c) -{ - if (_companies_ainew[c->index].state == AI_STATE_STARTUP) { - // The AI just got alive! - _companies_ainew[c->index].state = AI_STATE_FIRST_TIME; - _companies_ainew[c->index].tick = 0; - - // Only startup the AI - return; - } - - // We keep a ticker. We use it for competitor_speed - _companies_ainew[c->index].tick++; - - // If we come here, we can do a tick.. do so! - AiNew_OnTick(c); -} diff --git a/src/ai/trolly/trolly.h b/src/ai/trolly/trolly.h deleted file mode 100644 index 60180694c..000000000 --- a/src/ai/trolly/trolly.h +++ /dev/null @@ -1,344 +0,0 @@ -/* $Id$ */ - -/** @file trolly.h Functions/defines related to the trolly AI. */ - -#ifndef AI_TROLLY_H -#define AI_TROLLY_H - -#include "../../aystar.h" -#include "../../company_type.h" -#include "../../vehicle_type.h" -#include "../../date_type.h" -#include "../../engine_type.h" -#include "../../direction_type.h" - -/* - * These defines can be altered to change the behavoir of the AI - * - * WARNING: - * This can also alter the AI in a negative way. I will never claim these settings - * are perfect, but don't change them if you don't know what the effect is. - */ - -// How many times it the H multiplied. The higher, the more it will go straight to the -// end point. The lower, how more it will find the route with the lowest cost. -// also: the lower, the longer it takes before route is calculated.. -#define AI_PATHFINDER_H_MULTIPLER 100 - -// How many loops may AyStar do before it stops -// 0 = infinite -#define AI_PATHFINDER_LOOPS_PER_TICK 5 - -// How long may the AI search for one route? -// 0 = infinite -// This number is the number of tiles tested. -// It takes (AI_PATHFINDER_MAX_SEARCH_NODES / AI_PATHFINDER_LOOPS_PER_TICK) ticks -// to get here.. with 5000 / 10 = 500. 500 / 74 (one day) = 8 days till it aborts -// (that is: if the AI is on VERY FAST! :p -#define AI_PATHFINDER_MAX_SEARCH_NODES 5000 - -// If you enable this, the AI is not allowed to make 90degree turns -#define AI_PATHFINDER_NO_90DEGREES_TURN - -// Below are defines for the g-calculation - -// Standard penalty given to a tile -#define AI_PATHFINDER_PENALTY 150 -// The penalty given to a tile that is going up -#define AI_PATHFINDER_TILE_GOES_UP_PENALTY 450 -// The penalty given to a tile which would have to use fundation -#define AI_PATHFINDER_FOUNDATION_PENALTY 100 -// Changing direction is a penalty, to prevent curved ways (with that: slow ways) -#define AI_PATHFINDER_DIRECTION_CHANGE_PENALTY 200 -// Same penalty, only for when road already exists -#define AI_PATHFINDER_DIRECTION_CHANGE_ON_EXISTING_ROAD_PENALTY 50 -// A diagonal track cost the same as a straigh, but a diagonal is faster... so give -// a bonus for using diagonal track -#ifdef AI_PATHFINDER_NO_90DEGREES_TURN -#define AI_PATHFINDER_DIAGONAL_BONUS 95 -#else -#define AI_PATHFINDER_DIAGONAL_BONUS 75 -#endif -// If a roadblock already exists, it gets a bonus -#define AI_PATHFINDER_ROAD_ALREADY_EXISTS_BONUS 140 -// To prevent 3 direction changes in 3 tiles, this penalty is given in such situation -#define AI_PATHFINDER_CURVE_PENALTY 200 - -// Penalty a bridge gets per length -#define AI_PATHFINDER_BRIDGE_PENALTY 180 -// The penalty for a bridge going up -#define AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY 1000 - -// Tunnels are expensive... -// Because of that, every tile the cost is increased with 1/8th of his value -// This is also true if you are building a tunnel yourself -#define AI_PATHFINDER_TUNNEL_PENALTY 350 - -/* - * Ai_New defines - */ - -// How long may we search cities and industry for a new route? -#define AI_LOCATE_ROUTE_MAX_COUNTER 200 - -// How many days must there be between building the first station and the second station -// within one city. This number is in days and should be more than 4 months. -#define AI_CHECKCITY_DATE_BETWEEN 180 - -// How many cargo is needed for one station in a city? -#define AI_CHECKCITY_CARGO_PER_STATION 60 -// How much cargo must there not be used in a city before we can build a new station? -#define AI_CHECKCITY_NEEDED_CARGO 50 -// When there is already a station which takes the same good and the rating of that -// city is higher than this numer, we are not going to attempt to build anything -// there -#define AI_CHECKCITY_CARGO_RATING 50 -// But, there is a chance of 1 out of this number, that we do ;) -#define AI_CHECKCITY_CARGO_RATING_CHANCE 5 -// If a city is too small to contain a station, there is a small chance -// that we still do so.. just to make the city bigger! -#define AI_CHECKCITY_CITY_CHANCE 5 - -// This number indicates for every unit of cargo, how many tiles two stations maybe be away -// from eachother. In other words: if we have 120 units of cargo in one station, and 120 units -// of the cargo in the other station, both stations can be 96 units away from eachother, if the -// next number is 0.4. -#define AI_LOCATEROUTE_BUS_CARGO_DISTANCE 0.4 -#define AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE 0.7 -// In whole tiles, the minimum distance for a truck route -#define AI_LOCATEROUTE_TRUCK_MIN_DISTANCE 30 - -// The amount of tiles in a square from -X to +X that is scanned for a station spot -// (so if this number is 10, 20x20 = 400 tiles are scanned for _the_ perfect spot -// Safe values are between 15 and 5 -#define AI_FINDSTATION_TILE_RANGE 10 - -// Building on normal speed goes very fast. Idle this amount of ticks between every -// building part. It is calculated like this: (4 - competitor_speed) * num + 1 -// where competitor_speed is between 0 (very slow) to 4 (very fast) -#define AI_BUILDPATH_PAUSE 10 - -// Minimum % of reliabilty a vehicle has to have before the AI buys it -#define AI_VEHICLE_MIN_RELIABILTY 60 - -// The minimum amount of money a company should always have -#define AI_MINIMUM_MONEY 15000 - -// If the most cheap route is build, how much is it going to cost.. -// This is to prevent the AI from trying to build a route which can not be paid for -#define AI_MINIMUM_BUS_ROUTE_MONEY 25000 -#define AI_MINIMUM_TRUCK_ROUTE_MONEY 35000 - -// The minimum amount of money before we are going to repay any money -#define AI_MINIMUM_LOAN_REPAY_MONEY 40000 -// How many repays do we do if we have enough money to do so? -// Every repay is 10000 -#define AI_LOAN_REPAY 2 -// How much income must we have before paying back a loan? Month-based (and looked at the last month) -#define AI_MINIMUM_INCOME_FOR_LOAN 7000 - -// If there is <num> time as much cargo in the station then the vehicle can handle -// reuse the station instead of building a new one! -#define AI_STATION_REUSE_MULTIPLER 2 - -// No more than this amount of vehicles per station.. -#define AI_CHECK_MAX_VEHICLE_PER_STATION 10 - -// How many thick between building 2 vehicles -#define AI_BUILD_VEHICLE_TIME_BETWEEN DAY_TICKS - -// How many days must there between vehicle checks -// The more often, the less non-money-making lines there will be -// but the unfair it may seem to a human company -#define AI_DAYS_BETWEEN_VEHICLE_CHECKS 30 - -// How money profit does a vehicle needs to make to stay in order -// This is the profit of this year + profit of last year -// But also for vehicles that are just one year old. In other words: -// Vehicles of 2 years do easier meet this setting than vehicles -// of one year. This is a very good thing. New vehicles are filtered, -// while old vehicles stay longer, because we do get less in return. -#define AI_MINIMUM_ROUTE_PROFIT 1000 - -// A vehicle is considered lost when he his cargo is more than 180 days old -#define AI_VEHICLE_LOST_DAYS 180 - -// How many times may the AI try to find a route before it gives up -#define AI_MAX_TRIES_FOR_SAME_ROUTE 8 - -/* - * End of defines - */ - -// This stops 90degrees curves -static const byte _illegal_curves[6] = { - 255, 255, // Horz and vert, don't have the effect - 5, // upleft and upright are not valid - 4, // downright and downleft are not valid - 2, // downleft and upleft are not valid - 3, // upright and downright are not valid -}; - -enum { - AI_STATE_STARTUP = 0, - AI_STATE_FIRST_TIME, - AI_STATE_NOTHING, - AI_STATE_WAKE_UP, - AI_STATE_LOCATE_ROUTE, - AI_STATE_FIND_STATION, - AI_STATE_FIND_PATH, - AI_STATE_FIND_DEPOT, - AI_STATE_VERIFY_ROUTE, - AI_STATE_BUILD_STATION, - AI_STATE_BUILD_PATH, - AI_STATE_BUILD_DEPOT, - AI_STATE_BUILD_VEHICLE, - AI_STATE_WAIT_FOR_BUILD, - AI_STATE_GIVE_ORDERS, - AI_STATE_START_VEHICLE, - AI_STATE_REPAY_MONEY, - AI_STATE_CHECK_ALL_VEHICLES, - AI_STATE_ACTION_DONE, - AI_STATE_STOP, // Temporary function to stop the AI -}; - -// Used for tbt (train/bus/truck) -enum { - AI_TRAIN = 0, - AI_BUS, - AI_TRUCK, -}; - -enum { - AI_ACTION_NONE = 0, - AI_ACTION_BUS_ROUTE, - AI_ACTION_TRUCK_ROUTE, - AI_ACTION_REPAY_LOAN, - AI_ACTION_CHECK_ALL_VEHICLES, -}; - -// Used for from_type/to_type -enum { - AI_NO_TYPE = 0, - AI_CITY, - AI_INDUSTRY, -}; - -// Flags for in the vehicle -enum { - AI_VEHICLEFLAG_SELL = 1, - // Remember, flags must be in power of 2 -}; - -#define AI_NO_CARGO 0xFF // Means that there is no cargo defined yet (used for industry) -#define AI_NEED_CARGO 0xFE // Used when the AI needs to find out a cargo for the route -#define AI_STATION_RANGE TileXY(MapMaxX(), MapMaxY()) - -#define AI_PATHFINDER_NO_DIRECTION (byte)-1 - -// Flags used in user_data -#define AI_PATHFINDER_FLAG_BRIDGE 1 -#define AI_PATHFINDER_FLAG_TUNNEL 2 - -typedef void AiNew_StateFunction(Company *c); - -// ai_new.c -void AiNewDoGameLoop(Company *c); - -struct Ai_PathFinderInfo { - TileIndex start_tile_tl; ///< tl = top-left - TileIndex start_tile_br; ///< br = bottom-right - TileIndex end_tile_tl; ///< tl = top-left - TileIndex end_tile_br; ///< br = bottom-right - DiagDirection start_direction; ///< 0 to 3 or AI_PATHFINDER_NO_DIRECTION - DiagDirection end_direction; ///< 0 to 3 or AI_PATHFINDER_NO_DIRECTION - - TileIndex route[500]; - byte route_extra[500]; ///< Some extra information about the route like bridge/tunnel - int route_length; - int position; ///< Current position in the build-path, needed to build the path - - bool rail_or_road; ///< true = rail, false = road -}; - -// ai_pathfinder.c -AyStar *new_AyStar_AiPathFinder(int max_tiles_around, Ai_PathFinderInfo *PathFinderInfo); -void clean_AyStar_AiPathFinder(AyStar *aystar, Ai_PathFinderInfo *PathFinderInfo); - -// ai_shared.c -int AiNew_GetRailDirection(TileIndex tile_a, TileIndex tile_b, TileIndex tile_c); -int AiNew_GetRoadDirection(TileIndex tile_a, TileIndex tile_b, TileIndex tile_c); -DiagDirection AiNew_GetDirection(TileIndex tile_a, TileIndex tile_b); -bool AiNew_SetSpecialVehicleFlag(Company *c, Vehicle *v, uint flag); -uint AiNew_GetSpecialVehicleFlag(Company *c, Vehicle *v); - -// ai_build.c -bool AiNew_Build_CompanyHQ(Company *c, TileIndex tile); -CommandCost AiNew_Build_Station(Company *c, byte type, TileIndex tile, byte length, byte numtracks, byte direction, byte flag); -CommandCost AiNew_Build_Bridge(Company *c, TileIndex tile_a, TileIndex tile_b, byte flag); -CommandCost AiNew_Build_RoutePart(Company *c, Ai_PathFinderInfo *PathFinderInfo, byte flag); -EngineID AiNew_PickVehicle(Company *c); -CommandCost AiNew_Build_Vehicle(Company *c, TileIndex tile, byte flag); -CommandCost AiNew_Build_Depot(Company *c, TileIndex tile, DiagDirection direction, byte flag); - -/* The amount of memory reserved for the AI-special-vehicles */ -#define AI_MAX_SPECIAL_VEHICLES 100 - -struct Ai_SpecialVehicle { - VehicleID veh_id; - uint32 flag; -}; - -struct CompanyAiNew { - uint8 state; - uint tick; - uint idle; - - int temp; ///< A value used in more than one function, but it just temporary - ///< The use is pretty simple: with this we can 'think' about stuff - ///< in more than one tick, and more than one AI. A static will not - ///< do, because they are not saved. This way, the AI is almost human ;) - int counter; ///< For the same reason as temp, we have counter. It can count how - ///< long we are trying something, and just abort if it takes too long - - /* Pathfinder stuff */ - Ai_PathFinderInfo path_info; - AyStar *pathfinder; - - /* Route stuff */ - - CargoID cargo; - byte tbt; ///< train/bus/truck 0/1/2 AI_TRAIN/AI_BUS/AI_TRUCK - Money new_cost; - - byte action; - - int last_id; ///< here is stored the last id of the searched city/industry - Date last_vehiclecheck_date; // Used in CheckVehicle - Ai_SpecialVehicle special_vehicles[AI_MAX_SPECIAL_VEHICLES]; ///< Some vehicles have some special flags - - TileIndex from_tile; - TileIndex to_tile; - - DiagDirectionByte from_direction; - DiagDirectionByte to_direction; - - bool from_deliver; ///< True if this is the station that GIVES cargo - bool to_deliver; - - TileIndex depot_tile; - DiagDirectionByte depot_direction; - - byte amount_veh; ///< How many vehicles we are going to build in this route - byte cur_veh; ///< How many vehicles did we bought? - VehicleID veh_id; ///< Used when bought a vehicle - VehicleID veh_main_id; ///< The ID of the first vehicle, for shared copy - - int from_ic; ///< ic = industry/city. This is the ID of them - byte from_type; ///< AI_NO_TYPE/AI_CITY/AI_INDUSTRY - int to_ic; - byte to_type; -}; -extern CompanyAiNew _companies_ainew[MAX_COMPANIES]; - -#endif /* AI_TROLLY_H */ |