src/script/api/script_object.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_object.cpp Implementation of ScriptObject. */
   9
  10 #include "../../stdafx.h"
  11 #include "../../script/squirrel.hpp"
  12 #include "../../company_func.h"
  13 #include "../../company_base.h"
  14 #include "../../network/network.h"
  15 #include "../../genworld.h"
  16 #include "../../string_func.h"
  17 #include "../../strings_func.h"
  18 #include "../../command_func.h"
  19
  20 #include "../script_storage.hpp"
  21 #include "../script_instance.hpp"
  22 #include "../script_fatalerror.hpp"
  23 #include "script_error.hpp"
  24 #include "../../debug.h"
  25
  26 #include "../../safeguards.h"
  27
  28 void SimpleCountedObject::Release()
  29 {
  30         int32_t res = --this->ref_count;
  31         assert(res >= 0);
  32         if (res == 0) {
  33                 try {
  34                         this->FinalRelease(); // may throw, for example ScriptTest/ExecMode
  35                 } catch (...) {
  36                         delete this;
  37                         throw;
  38                 }
  39                 delete this;
  40         }
  41 }
  42
  43 /**
  44  * Get the storage associated with the current ScriptInstance.
  45  * @return The storage.
  46  */
  47 static ScriptStorage *GetStorage()
  48 {
  49         return ScriptObject::GetActiveInstance()->GetStorage();
  50 }
  51
  52
  53 /* static */ ScriptInstance *ScriptObject::ActiveInstance::active = nullptr;
  54
  55 ScriptObject::ActiveInstance::ActiveInstance(ScriptInstance *instance) : alc_scope(instance->engine)
  56 {
  57         this->last_active = ScriptObject::ActiveInstance::active;
  58         ScriptObject::ActiveInstance::active = instance;
  59 }
  60
  61 ScriptObject::ActiveInstance::~ActiveInstance()
  62 {
  63         ScriptObject::ActiveInstance::active = this->last_active;
  64 }
  65
  66 /* static */ ScriptInstance *ScriptObject::GetActiveInstance()
  67 {
  68         assert(ScriptObject::ActiveInstance::active != nullptr);
  69         return ScriptObject::ActiveInstance::active;
  70 }
  71
  72
  73 /* static */ void ScriptObject::SetDoCommandDelay(uint ticks)
  74 {
  75         assert(ticks > 0);
  76         GetStorage()->delay = ticks;
  77 }
  78
  79 /* static */ uint ScriptObject::GetDoCommandDelay()
  80 {
  81         return GetStorage()->delay;
  82 }
  83
  84 /* static */ void ScriptObject::SetDoCommandMode(ScriptModeProc *proc, ScriptObject *instance)
  85 {
  86         GetStorage()->mode = proc;
  87         GetStorage()->mode_instance = instance;
  88 }
  89
  90 /* static */ ScriptModeProc *ScriptObject::GetDoCommandMode()
  91 {
  92         return GetStorage()->mode;
  93 }
  94
  95 /* static */ ScriptObject *ScriptObject::GetDoCommandModeInstance()
  96 {
  97         return GetStorage()->mode_instance;
  98 }
  99
 100 /* static */ void ScriptObject::SetDoCommandAsyncMode(ScriptAsyncModeProc *proc, ScriptObject *instance)
 101 {
 102         GetStorage()->async_mode = proc;
 103         GetStorage()->async_mode_instance = instance;
 104 }
 105
 106 /* static */ ScriptAsyncModeProc *ScriptObject::GetDoCommandAsyncMode()
 107 {
 108         return GetStorage()->async_mode;
 109 }
 110
 111 /* static */ ScriptObject *ScriptObject::GetDoCommandAsyncModeInstance()
 112 {
 113         return GetStorage()->async_mode_instance;
 114 }
 115
 116 /* static */ void ScriptObject::SetLastCommand(const CommandDataBuffer &data, Commands cmd)
 117 {
 118         ScriptStorage *s = GetStorage();
 119         Debug(script, 6, "SetLastCommand company={:02d} cmd={} data={}", s->root_company, cmd, FormatArrayAsHex(data));
 120         s->last_data = data;
 121         s->last_cmd = cmd;
 122 }
 123
 124 /* static */ bool ScriptObject::CheckLastCommand(const CommandDataBuffer &data, Commands cmd)
 125 {
 126         ScriptStorage *s = GetStorage();
 127         Debug(script, 6, "CheckLastCommand company={:02d} cmd={} data={}", s->root_company, cmd, FormatArrayAsHex(data));
 128         if (s->last_cmd != cmd) return false;
 129         if (s->last_data != data) return false;
 130         return true;
 131 }
 132
 133 /* static */ void ScriptObject::SetDoCommandCosts(Money value)
 134 {
 135         GetStorage()->costs = CommandCost(INVALID_EXPENSES, value); // Expense type is never read.
 136 }
 137
 138 /* static */ void ScriptObject::IncreaseDoCommandCosts(Money value)
 139 {
 140         GetStorage()->costs.AddCost(value);
 141 }
 142
 143 /* static */ Money ScriptObject::GetDoCommandCosts()
 144 {
 145         return GetStorage()->costs.GetCost();
 146 }
 147
 148 /* static */ void ScriptObject::SetLastError(ScriptErrorType last_error)
 149 {
 150         GetStorage()->last_error = last_error;
 151 }
 152
 153 /* static */ ScriptErrorType ScriptObject::GetLastError()
 154 {
 155         return GetStorage()->last_error;
 156 }
 157
 158 /* static */ void ScriptObject::SetLastCost(Money last_cost)
 159 {
 160         GetStorage()->last_cost = last_cost;
 161 }
 162
 163 /* static */ Money ScriptObject::GetLastCost()
 164 {
 165         return GetStorage()->last_cost;
 166 }
 167
 168 /* static */ void ScriptObject::SetRoadType(RoadType road_type)
 169 {
 170         GetStorage()->road_type = road_type;
 171 }
 172
 173 /* static */ RoadType ScriptObject::GetRoadType()
 174 {
 175         return GetStorage()->road_type;
 176 }
 177
 178 /* static */ void ScriptObject::SetRailType(RailType rail_type)
 179 {
 180         GetStorage()->rail_type = rail_type;
 181 }
 182
 183 /* static */ RailType ScriptObject::GetRailType()
 184 {
 185         return GetStorage()->rail_type;
 186 }
 187
 188 /* static */ void ScriptObject::SetLastCommandRes(bool res)
 189 {
 190         GetStorage()->last_command_res = res;
 191 }
 192
 193 /* static */ bool ScriptObject::GetLastCommandRes()
 194 {
 195         return GetStorage()->last_command_res;
 196 }
 197
 198 /* static */ void ScriptObject::SetLastCommandResData(CommandDataBuffer data)
 199 {
 200         GetStorage()->last_cmd_ret = std::move(data);
 201 }
 202
 203 /* static */ const CommandDataBuffer &ScriptObject::GetLastCommandResData()
 204 {
 205         return GetStorage()->last_cmd_ret;
 206 }
 207
 208 /* static */ void ScriptObject::SetAllowDoCommand(bool allow)
 209 {
 210         GetStorage()->allow_do_command = allow;
 211 }
 212
 213 /* static */ bool ScriptObject::GetAllowDoCommand()
 214 {
 215         return GetStorage()->allow_do_command;
 216 }
 217
 218 /* static */ void ScriptObject::SetCompany(CompanyID company)
 219 {
 220         if (GetStorage()->root_company == INVALID_OWNER) GetStorage()->root_company = company;
 221         GetStorage()->company = company;
 222
 223         _current_company = company;
 224 }
 225
 226 /* static */ CompanyID ScriptObject::GetCompany()
 227 {
 228         return GetStorage()->company;
 229 }
 230
 231 /* static */ CompanyID ScriptObject::GetRootCompany()
 232 {
 233         return GetStorage()->root_company;
 234 }
 235
 236 /* static */ bool ScriptObject::CanSuspend()
 237 {
 238         Squirrel *squirrel = ScriptObject::GetActiveInstance()->engine;
 239         return GetStorage()->allow_do_command && squirrel->CanSuspend();
 240 }
 241
 242 /* static */ void *&ScriptObject::GetEventPointer()
 243 {
 244         return GetStorage()->event_data;
 245 }
 246
 247 /* static */ ScriptLogTypes::LogData &ScriptObject::GetLogData()
 248 {
 249         return GetStorage()->log_data;
 250 }
 251
 252 /* static */ std::string ScriptObject::GetString(StringID string)
 253 {
 254         return ::StrMakeValid(::GetString(string));
 255 }
 256
 257 /* static */ void ScriptObject::SetCallbackVariable(int index, int value)
 258 {
 259         if (static_cast<size_t>(index) >= GetStorage()->callback_value.size()) GetStorage()->callback_value.resize(index + 1);
 260         GetStorage()->callback_value[index] = value;
 261 }
 262
 263 /* static */ int ScriptObject::GetCallbackVariable(int index)
 264 {
 265         return GetStorage()->callback_value[index];
 266 }
 267
 268 /* static */ CommandCallbackData *ScriptObject::GetDoCommandCallback()
 269 {
 270         return ScriptObject::GetActiveInstance()->GetDoCommandCallback();
 271 }
 272
 273 std::tuple<bool, bool, bool, bool> ScriptObject::DoCommandPrep()
 274 {
 275         if (!ScriptObject::CanSuspend()) {
 276                 throw Script_FatalError("You are not allowed to execute any DoCommand (even indirect) in your constructor, Save(), Load(), and any valuator.");
 277         }
 278
 279         /* Are we only interested in the estimate costs? */
 280         bool estimate_only = GetDoCommandMode() != nullptr && !GetDoCommandMode()();
 281
 282         /* Should the command be executed asynchronously? */
 283         bool asynchronous = GetDoCommandAsyncMode() != nullptr && GetDoCommandAsyncMode()();
 284
 285         bool networking = _networking && !_generating_world;
 286
 287         if (!ScriptCompanyMode::IsDeity() && !ScriptCompanyMode::IsValid()) {
 288                 ScriptObject::SetLastError(ScriptError::ERR_PRECONDITION_INVALID_COMPANY);
 289                 return { true, estimate_only, asynchronous, networking };
 290         }
 291
 292         return { false, estimate_only, asynchronous, networking };
 293 }
 294
 295 bool ScriptObject::DoCommandProcessResult(const CommandCost &res, Script_SuspendCallbackProc *callback, bool estimate_only, bool asynchronous)
 296 {
 297         /* Set the default callback to return a true/false result of the DoCommand */
 298         if (callback == nullptr) callback = &ScriptInstance::DoCommandReturn;
 299
 300         /* We failed; set the error and bail out */
 301         if (res.Failed()) {
 302                 SetLastError(ScriptError::StringToError(res.GetErrorMessage()));
 303                 return false;
 304         }
 305
 306         /* No error, then clear it. */
 307         SetLastError(ScriptError::ERR_NONE);
 308
 309         /* Estimates, update the cost for the estimate and be done */
 310         if (estimate_only) {
 311                 IncreaseDoCommandCosts(res.GetCost());
 312                 return true;
 313         }
 314
 315         /* Costs of this operation. */
 316         SetLastCost(res.GetCost());
 317         SetLastCommandRes(true);
 318
 319         if (_generating_world || asynchronous) {
 320                 IncreaseDoCommandCosts(res.GetCost());
 321                 if (!_generating_world) {
 322                         /* Charge a nominal fee for asynchronously executed commands */
 323                         Squirrel *engine = ScriptObject::GetActiveInstance()->engine;
 324                         Squirrel::DecreaseOps(engine->GetVM(), 100);
 325                 }
 326                 if (callback != nullptr) {
 327                         /* Insert return value into to stack and throw a control code that
 328                          * the return value in the stack should be used. */
 329                         callback(GetActiveInstance());
 330                         throw SQInteger(1);
 331                 }
 332                 return true;
 333         } else if (_networking) {
 334                 /* Suspend the script till the command is really executed. */
 335                 throw Script_Suspend(-(int)GetDoCommandDelay(), callback);
 336         } else {
 337                 IncreaseDoCommandCosts(res.GetCost());
 338
 339                 /* Suspend the script player for 1+ ticks, so it simulates multiplayer. This
 340                  *  both avoids confusion when a developer launched the script in a
 341                  *  multiplayer game, but also gives time for the GUI and human player
 342                  *  to interact with the game. */
 343                 throw Script_Suspend(GetDoCommandDelay(), callback);
 344         }
 345
 346         NOT_REACHED();
 347 }
 348
 349
 350 /* static */ Randomizer ScriptObject::random_states[OWNER_END];
 351
 352 Randomizer &ScriptObject::GetRandomizer(Owner owner)
 353 {
 354         return ScriptObject::random_states[owner];
 355 }
 356
 357 void ScriptObject::InitializeRandomizers()
 358 {
 359         Randomizer random = _random;
 360         for (Owner owner = OWNER_BEGIN; owner < OWNER_END; owner++) {
 361                 ScriptObject::GetRandomizer(owner).SetSeed(random.Next());
 362         }
 363 }