src/script/api/script_object.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file script_object.cpp Implementation of ScriptObject. */
  11
  12 #include "../../stdafx.h"
  13 #include "../../script/squirrel.hpp"
  14 #include "../../command_func.h"
  15 #include "../../company_func.h"
  16 #include "../../company_base.h"
  17 #include "../../network/network.h"
  18 #include "../../genworld.h"
  19 #include "../../string_func.h"
  20 #include "../../strings_func.h"
  21
  22 #include "../script_storage.hpp"
  23 #include "../script_instance.hpp"
  24 #include "../script_fatalerror.hpp"
  25 #include "script_error.hpp"
  26
  27 #include "../../safeguards.h"
  28
  29 /**
  30  * Get the storage associated with the current ScriptInstance.
  31  * @return The storage.
  32  */
  33 static ScriptStorage *GetStorage()
  34 {
  35         return ScriptObject::GetActiveInstance()->GetStorage();
  36 }
  37
  38
  39 /* static */ ScriptInstance *ScriptObject::ActiveInstance::active = NULL;
  40
  41 ScriptObject::ActiveInstance::ActiveInstance(ScriptInstance *instance)
  42 {
  43         this->last_active = ScriptObject::ActiveInstance::active;
  44         ScriptObject::ActiveInstance::active = instance;
  45 }
  46
  47 ScriptObject::ActiveInstance::~ActiveInstance()
  48 {
  49         ScriptObject::ActiveInstance::active = this->last_active;
  50 }
  51
  52 /* static */ ScriptInstance *ScriptObject::GetActiveInstance()
  53 {
  54         assert(ScriptObject::ActiveInstance::active != NULL);
  55         return ScriptObject::ActiveInstance::active;
  56 }
  57
  58
  59 /* static */ void ScriptObject::SetDoCommandDelay(uint ticks)
  60 {
  61         assert(ticks > 0);
  62         GetStorage()->delay = ticks;
  63 }
  64
  65 /* static */ uint ScriptObject::GetDoCommandDelay()
  66 {
  67         return GetStorage()->delay;
  68 }
  69
  70 /* static */ void ScriptObject::SetDoCommandMode(ScriptModeProc *proc, ScriptObject *instance)
  71 {
  72         GetStorage()->mode = proc;
  73         GetStorage()->mode_instance = instance;
  74 }
  75
  76 /* static */ ScriptModeProc *ScriptObject::GetDoCommandMode()
  77 {
  78         return GetStorage()->mode;
  79 }
  80
  81 /* static */ ScriptObject *ScriptObject::GetDoCommandModeInstance()
  82 {
  83         return GetStorage()->mode_instance;
  84 }
  85
  86 /* static */ void ScriptObject::SetDoCommandCosts(Money value)
  87 {
  88         GetStorage()->costs = CommandCost(value);
  89 }
  90
  91 /* static */ void ScriptObject::IncreaseDoCommandCosts(Money value)
  92 {
  93         GetStorage()->costs.AddCost(value);
  94 }
  95
  96 /* static */ Money ScriptObject::GetDoCommandCosts()
  97 {
  98         return GetStorage()->costs.GetCost();
  99 }
 100
 101 /* static */ void ScriptObject::SetLastError(ScriptErrorType last_error)
 102 {
 103         GetStorage()->last_error = last_error;
 104 }
 105
 106 /* static */ ScriptErrorType ScriptObject::GetLastError()
 107 {
 108         return GetStorage()->last_error;
 109 }
 110
 111 /* static */ void ScriptObject::SetLastCost(Money last_cost)
 112 {
 113         GetStorage()->last_cost = last_cost;
 114 }
 115
 116 /* static */ Money ScriptObject::GetLastCost()
 117 {
 118         return GetStorage()->last_cost;
 119 }
 120
 121 /* static */ void ScriptObject::SetRoadType(RoadType road_type)
 122 {
 123         GetStorage()->road_type = road_type;
 124 }
 125
 126 /* static */ RoadType ScriptObject::GetRoadType()
 127 {
 128         return GetStorage()->road_type;
 129 }
 130
 131 /* static */ void ScriptObject::SetRailType(RailType rail_type)
 132 {
 133         GetStorage()->rail_type = rail_type;
 134 }
 135
 136 /* static */ RailType ScriptObject::GetRailType()
 137 {
 138         return GetStorage()->rail_type;
 139 }
 140
 141 /* static */ void ScriptObject::SetLastCommandRes(bool res)
 142 {
 143         GetStorage()->last_command_res = res;
 144         /* Also store the results of various global variables */
 145         SetNewVehicleID(_new_vehicle_id);
 146         SetNewSignID(_new_sign_id);
 147         SetNewGroupID(_new_group_id);
 148         SetNewGoalID(_new_goal_id);
 149         SetNewStoryPageID(_new_story_page_id);
 150         SetNewStoryPageElementID(_new_story_page_element_id);
 151 }
 152
 153 /* static */ bool ScriptObject::GetLastCommandRes()
 154 {
 155         return GetStorage()->last_command_res;
 156 }
 157
 158 /* static */ void ScriptObject::SetNewVehicleID(VehicleID vehicle_id)
 159 {
 160         GetStorage()->new_vehicle_id = vehicle_id;
 161 }
 162
 163 /* static */ VehicleID ScriptObject::GetNewVehicleID()
 164 {
 165         return GetStorage()->new_vehicle_id;
 166 }
 167
 168 /* static */ void ScriptObject::SetNewSignID(SignID sign_id)
 169 {
 170         GetStorage()->new_sign_id = sign_id;
 171 }
 172
 173 /* static */ SignID ScriptObject::GetNewSignID()
 174 {
 175         return GetStorage()->new_sign_id;
 176 }
 177
 178 /* static */ void ScriptObject::SetNewGroupID(GroupID group_id)
 179 {
 180         GetStorage()->new_group_id = group_id;
 181 }
 182
 183 /* static */ GroupID ScriptObject::GetNewGroupID()
 184 {
 185         return GetStorage()->new_group_id;
 186 }
 187
 188 /* static */ void ScriptObject::SetNewGoalID(GoalID goal_id)
 189 {
 190         GetStorage()->new_goal_id = goal_id;
 191 }
 192
 193 /* static */ GroupID ScriptObject::GetNewGoalID()
 194 {
 195         return GetStorage()->new_goal_id;
 196 }
 197
 198 /* static */ void ScriptObject::SetNewStoryPageID(StoryPageID story_page_id)
 199 {
 200         GetStorage()->new_story_page_id = story_page_id;
 201 }
 202
 203 /* static */ GroupID ScriptObject::GetNewStoryPageID()
 204 {
 205         return GetStorage()->new_story_page_id;
 206 }
 207
 208 /* static */ void ScriptObject::SetNewStoryPageElementID(StoryPageElementID story_page_element_id)
 209 {
 210         GetStorage()->new_story_page_element_id = story_page_element_id;
 211 }
 212
 213 /* static */ GroupID ScriptObject::GetNewStoryPageElementID()
 214 {
 215         return GetStorage()->new_story_page_element_id;
 216 }
 217
 218 /* static */ void ScriptObject::SetAllowDoCommand(bool allow)
 219 {
 220         GetStorage()->allow_do_command = allow;
 221 }
 222
 223 /* static */ bool ScriptObject::GetAllowDoCommand()
 224 {
 225         return GetStorage()->allow_do_command;
 226 }
 227
 228 /* static */ void ScriptObject::SetCompany(CompanyID company)
 229 {
 230         if (GetStorage()->root_company == INVALID_OWNER) GetStorage()->root_company = company;
 231         GetStorage()->company = company;
 232
 233         _current_company = company;
 234 }
 235
 236 /* static */ CompanyID ScriptObject::GetCompany()
 237 {
 238         return GetStorage()->company;
 239 }
 240
 241 /* static */ CompanyID ScriptObject::GetRootCompany()
 242 {
 243         return GetStorage()->root_company;
 244 }
 245
 246 /* static */ bool ScriptObject::CanSuspend()
 247 {
 248         Squirrel *squirrel = ScriptObject::GetActiveInstance()->engine;
 249         return GetStorage()->allow_do_command && squirrel->CanSuspend();
 250 }
 251
 252 /* static */ void *&ScriptObject::GetEventPointer()
 253 {
 254         return GetStorage()->event_data;
 255 }
 256
 257 /* static */ void *&ScriptObject::GetLogPointer()
 258 {
 259         return GetStorage()->log_data;
 260 }
 261
 262 /* static */ char *ScriptObject::GetString(StringID string)
 263 {
 264         char buffer[64];
 265         ::GetString(buffer, string, lastof(buffer));
 266         ::str_validate(buffer, lastof(buffer), SVS_NONE);
 267         return ::stredup(buffer);
 268 }
 269
 270 /* static */ void ScriptObject::SetCallbackVariable(int index, int value)
 271 {
 272         if ((size_t)index >= GetStorage()->callback_value.size()) GetStorage()->callback_value.resize(index + 1);
 273         GetStorage()->callback_value[index] = value;
 274 }
 275
 276 /* static */ int ScriptObject::GetCallbackVariable(int index)
 277 {
 278         return GetStorage()->callback_value[index];
 279 }
 280
 281 /* static */ bool ScriptObject::DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint cmd, const char *text, Script_SuspendCallbackProc *callback)
 282 {
 283         if (!ScriptObject::CanSuspend()) {
 284                 throw Script_FatalError("You are not allowed to execute any DoCommand (even indirect) in your constructor, Save(), Load(), and any valuator.");
 285         }
 286
 287         if (ScriptObject::GetCompany() != OWNER_DEITY && !::Company::IsValidID(ScriptObject::GetCompany())) {
 288                 ScriptObject::SetLastError(ScriptError::ERR_PRECONDITION_INVALID_COMPANY);
 289                 return false;
 290         }
 291
 292         if (!StrEmpty(text) && (GetCommandFlags(cmd) & CMD_STR_CTRL) == 0) {
 293                 /* The string must be valid, i.e. not contain special codes. Since some
 294                  * can be made with GSText, make sure the control codes are removed. */
 295                 ::str_validate(const_cast<char *>(text), text + strlen(text), SVS_NONE);
 296         }
 297
 298         /* Set the default callback to return a true/false result of the DoCommand */
 299         if (callback == NULL) callback = &ScriptInstance::DoCommandReturn;
 300
 301         /* Are we only interested in the estimate costs? */
 302         bool estimate_only = GetDoCommandMode() != NULL && !GetDoCommandMode()();
 303
 304 #ifdef ENABLE_NETWORK
 305         /* Only set p2 when the command does not come from the network. */
 306         if (GetCommandFlags(cmd) & CMD_CLIENT_ID && p2 == 0) p2 = UINT32_MAX;
 307 #endif
 308
 309         /* Try to perform the command. */
 310         CommandCost res = ::DoCommandPInternal(tile, p1, p2, cmd, (_networking && !_generating_world) ? ScriptObject::GetActiveInstance()->GetDoCommandCallback() : NULL, text, false, estimate_only, 0);
 311
 312         /* We failed; set the error and bail out */
 313         if (res.Failed()) {
 314                 SetLastError(ScriptError::StringToError(res.GetErrorMessage()));
 315                 return false;
 316         }
 317
 318         /* No error, then clear it. */
 319         SetLastError(ScriptError::ERR_NONE);
 320
 321         /* Estimates, update the cost for the estimate and be done */
 322         if (estimate_only) {
 323                 IncreaseDoCommandCosts(res.GetCost());
 324                 return true;
 325         }
 326
 327         /* Costs of this operation. */
 328         SetLastCost(res.GetCost());
 329         SetLastCommandRes(true);
 330
 331         if (_generating_world) {
 332                 IncreaseDoCommandCosts(res.GetCost());
 333                 if (callback != NULL) {
 334                         /* Insert return value into to stack and throw a control code that
 335                          * the return value in the stack should be used. */
 336                         callback(GetActiveInstance());
 337                         throw SQInteger(1);
 338                 }
 339                 return true;
 340         } else if (_networking) {
 341                 /* Suspend the script till the command is really executed. */
 342                 throw Script_Suspend(-(int)GetDoCommandDelay(), callback);
 343         } else {
 344                 IncreaseDoCommandCosts(res.GetCost());
 345
 346                 /* Suspend the script player for 1+ ticks, so it simulates multiplayer. This
 347                  *  both avoids confusion when a developer launched his script in a
 348                  *  multiplayer game, but also gives time for the GUI and human player
 349                  *  to interact with the game. */
 350                 throw Script_Suspend(GetDoCommandDelay(), callback);
 351         }
 352
 353         NOT_REACHED();
 354 }