src/script/script_config.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file script_config.cpp Implementation of ScriptConfig. */
   9
  10 #include "../stdafx.h"
  11 #include "../settings_type.h"
  12 #include "../core/random_func.hpp"
  13 #include "script_info.hpp"
  14 #include "api/script_object.hpp"
  15 #include "../textfile_gui.h"
  16 #include "../string_func.h"
  17 #include <charconv>
  18
  19 #include "../safeguards.h"
  20
  21 void ScriptConfig::Change(std::optional<const std::string> name, int version, bool force_exact_match)
  22 {
  23         if (name.has_value()) {
  24                 this->name = std::move(name.value());
  25                 this->info = this->FindInfo(this->name, version, force_exact_match);
  26         } else {
  27                 this->info = nullptr;
  28         }
  29         this->version = (info == nullptr) ? -1 : info->GetVersion();
  30         this->config_list.reset();
  31         this->to_load_data.reset();
  32
  33         this->ClearConfigList();
  34 }
  35
  36 ScriptConfig::ScriptConfig(const ScriptConfig *config)
  37 {
  38         this->name = config->name;
  39         this->info = config->info;
  40         this->version = config->version;
  41         this->to_load_data.reset();
  42
  43         for (const auto &item : config->settings) {
  44                 this->settings[item.first] = item.second;
  45         }
  46 }
  47
  48 ScriptConfig::~ScriptConfig()
  49 {
  50         this->ResetSettings();
  51         this->to_load_data.reset();
  52 }
  53
  54 ScriptInfo *ScriptConfig::GetInfo() const
  55 {
  56         return this->info;
  57 }
  58
  59 const ScriptConfigItemList *ScriptConfig::GetConfigList()
  60 {
  61         if (this->info != nullptr) return this->info->GetConfigList();
  62         if (this->config_list == nullptr) {
  63                 this->config_list = std::make_unique<ScriptConfigItemList>();
  64         }
  65         return this->config_list.get();
  66 }
  67
  68 void ScriptConfig::ClearConfigList()
  69 {
  70         this->settings.clear();
  71 }
  72
  73 void ScriptConfig::AnchorUnchangeableSettings()
  74 {
  75         for (const auto &item : *this->GetConfigList()) {
  76                 if ((item.flags & SCRIPTCONFIG_INGAME) == 0) {
  77                         this->SetSetting(item.name, this->GetSetting(item.name));
  78                 }
  79         }
  80 }
  81
  82 int ScriptConfig::GetSetting(const std::string &name) const
  83 {
  84         const auto it = this->settings.find(name);
  85         if (it == this->settings.end()) return this->info->GetSettingDefaultValue(name);
  86         return (*it).second;
  87 }
  88
  89 void ScriptConfig::SetSetting(const std::string_view name, int value)
  90 {
  91         /* You can only set Script specific settings if an Script is selected. */
  92         if (this->info == nullptr) return;
  93
  94         const ScriptConfigItem *config_item = this->info->GetConfigItem(name);
  95         if (config_item == nullptr) return;
  96
  97         value = Clamp(value, config_item->min_value, config_item->max_value);
  98
  99         this->settings[std::string{name}] = value;
 100 }
 101
 102 void ScriptConfig::ResetSettings()
 103 {
 104         this->settings.clear();
 105 }
 106
 107 void ScriptConfig::ResetEditableSettings(bool yet_to_start)
 108 {
 109         if (this->info == nullptr) return ResetSettings();
 110
 111         for (SettingValueList::iterator it = this->settings.begin(); it != this->settings.end();) {
 112                 const ScriptConfigItem *config_item = this->info->GetConfigItem(it->first);
 113                 assert(config_item != nullptr);
 114
 115                 bool editable = yet_to_start || (config_item->flags & SCRIPTCONFIG_INGAME) != 0;
 116                 bool visible = _settings_client.gui.ai_developer_tools || (config_item->flags & SCRIPTCONFIG_DEVELOPER) == 0;
 117
 118                 if (editable && visible) {
 119                         it = this->settings.erase(it);
 120                 } else {
 121                         it++;
 122                 }
 123         }
 124 }
 125
 126 bool ScriptConfig::HasScript() const
 127 {
 128         return this->info != nullptr;
 129 }
 130
 131 const std::string &ScriptConfig::GetName() const
 132 {
 133         return this->name;
 134 }
 135
 136 int ScriptConfig::GetVersion() const
 137 {
 138         return this->version;
 139 }
 140
 141 void ScriptConfig::StringToSettings(const std::string &value)
 142 {
 143         std::string_view to_process = value;
 144         for (;;) {
 145                 /* Analyze the string ('name=value,name=value\0') */
 146                 size_t pos = to_process.find_first_of('=');
 147                 if (pos == std::string_view::npos) return;
 148
 149                 std::string_view item_name = to_process.substr(0, pos);
 150
 151                 to_process.remove_prefix(pos + 1);
 152                 pos = to_process.find_first_of(',');
 153                 int item_value = 0;
 154                 std::from_chars(to_process.data(), to_process.data() + std::min(pos, to_process.size()), item_value);
 155
 156                 this->SetSetting(item_name, item_value);
 157
 158                 if (pos == std::string_view::npos) return;
 159                 to_process.remove_prefix(pos + 1);
 160         }
 161 }
 162
 163 std::string ScriptConfig::SettingsToString() const
 164 {
 165         if (this->settings.empty()) return {};
 166
 167         std::string result;
 168         for (const auto &item : this->settings) {
 169                 fmt::format_to(std::back_inserter(result), "{}={},", item.first, item.second);
 170         }
 171
 172         /* Remove the last ','. */
 173         result.resize(result.size() - 1);
 174         return result;
 175 }
 176
 177 std::optional<std::string> ScriptConfig::GetTextfile(TextfileType type, CompanyID slot) const
 178 {
 179         if (slot == INVALID_COMPANY || this->GetInfo() == nullptr) return std::nullopt;
 180
 181         return ::GetTextfile(type, (slot == OWNER_DEITY) ? GAME_DIR : AI_DIR, this->GetInfo()->GetMainScript());
 182 }
 183
 184 void ScriptConfig::SetToLoadData(ScriptInstance::ScriptData *data)
 185 {
 186         this->to_load_data.reset(data);
 187 }
 188
 189 ScriptInstance::ScriptData *ScriptConfig::GetToLoadData()
 190 {
 191         return this->to_load_data.get();
 192 }
 193