src/command.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 command.cpp Handling of commands. */
   9
  10 #include "stdafx.h"
  11 #include "landscape.h"
  12 #include "error.h"
  13 #include "gui.h"
  14 #include "command_func.h"
  15 #include "network/network_type.h"
  16 #include "network/network.h"
  17 #include "genworld.h"
  18 #include "strings_func.h"
  19 #include "texteff.hpp"
  20 #include "town.h"
  21 #include "date_func.h"
  22 #include "company_func.h"
  23 #include "company_base.h"
  24 #include "signal_func.h"
  25 #include "core/backup_type.hpp"
  26 #include "object_base.h"
  27
  28 #include "table/strings.h"
  29
  30 #include "safeguards.h"
  31
  32 CommandProc CmdBuildRailroadTrack;
  33 CommandProc CmdRemoveRailroadTrack;
  34 CommandProc CmdBuildSingleRail;
  35 CommandProc CmdRemoveSingleRail;
  36
  37 CommandProc CmdLandscapeClear;
  38
  39 CommandProc CmdBuildBridge;
  40
  41 CommandProc CmdBuildRailStation;
  42 CommandProc CmdRemoveFromRailStation;
  43 CommandProc CmdConvertRail;
  44
  45 CommandProc CmdBuildSingleSignal;
  46 CommandProc CmdRemoveSingleSignal;
  47
  48 CommandProc CmdTerraformLand;
  49
  50 CommandProc CmdBuildObject;
  51 CommandProc CmdSellLandArea;
  52
  53 CommandProc CmdBuildTunnel;
  54
  55 CommandProc CmdBuildTrainDepot;
  56 CommandProc CmdBuildRailWaypoint;
  57 CommandProc CmdRenameWaypoint;
  58 CommandProc CmdRemoveFromRailWaypoint;
  59
  60 CommandProc CmdBuildRoadStop;
  61 CommandProc CmdRemoveRoadStop;
  62
  63 CommandProc CmdBuildLongRoad;
  64 CommandProc CmdRemoveLongRoad;
  65 CommandProc CmdBuildRoad;
  66
  67 CommandProc CmdBuildRoadDepot;
  68
  69 CommandProc CmdConvertRoad;
  70
  71 CommandProc CmdBuildAirport;
  72
  73 CommandProc CmdBuildDock;
  74
  75 CommandProc CmdBuildShipDepot;
  76
  77 CommandProc CmdBuildBuoy;
  78
  79 CommandProc CmdPlantTree;
  80
  81 CommandProc CmdMoveRailVehicle;
  82
  83 CommandProc CmdBuildVehicle;
  84 CommandProc CmdSellVehicle;
  85 CommandProc CmdRefitVehicle;
  86 CommandProc CmdSendVehicleToDepot;
  87 CommandProc CmdSetVehicleVisibility;
  88
  89 CommandProc CmdForceTrainProceed;
  90 CommandProc CmdReverseTrainDirection;
  91
  92 CommandProc CmdClearOrderBackup;
  93 CommandProc CmdModifyOrder;
  94 CommandProc CmdSkipToOrder;
  95 CommandProc CmdDeleteOrder;
  96 CommandProc CmdInsertOrder;
  97 CommandProc CmdChangeServiceInt;
  98
  99 CommandProc CmdBuildIndustry;
 100 CommandProc CmdIndustryCtrl;
 101
 102 CommandProc CmdSetCompanyManagerFace;
 103 CommandProc CmdSetCompanyColour;
 104
 105 CommandProc CmdIncreaseLoan;
 106 CommandProc CmdDecreaseLoan;
 107
 108 CommandProc CmdWantEnginePreview;
 109 CommandProc CmdEngineCtrl;
 110
 111 CommandProc CmdRenameVehicle;
 112 CommandProc CmdRenameEngine;
 113
 114 CommandProc CmdRenameCompany;
 115 CommandProc CmdRenamePresident;
 116
 117 CommandProc CmdRenameStation;
 118 CommandProc CmdRenameDepot;
 119
 120 CommandProc CmdPlaceSign;
 121 CommandProc CmdRenameSign;
 122
 123 CommandProc CmdTurnRoadVeh;
 124
 125 CommandProc CmdPause;
 126
 127 CommandProc CmdBuyShareInCompany;
 128 CommandProc CmdSellShareInCompany;
 129 CommandProc CmdBuyCompany;
 130
 131 CommandProc CmdFoundTown;
 132 CommandProc CmdRenameTown;
 133 CommandProc CmdDoTownAction;
 134 CommandProc CmdTownGrowthRate;
 135 CommandProc CmdTownRating;
 136 CommandProc CmdTownCargoGoal;
 137 CommandProc CmdTownSetText;
 138 CommandProc CmdExpandTown;
 139 CommandProc CmdDeleteTown;
 140
 141 CommandProc CmdChangeSetting;
 142 CommandProc CmdChangeCompanySetting;
 143
 144 CommandProc CmdOrderRefit;
 145 CommandProc CmdCloneOrder;
 146
 147 CommandProc CmdClearArea;
 148
 149 CommandProc CmdGiveMoney;
 150 CommandProc CmdMoneyCheat;
 151 CommandProc CmdChangeBankBalance;
 152 CommandProc CmdBuildCanal;
 153 CommandProc CmdBuildLock;
 154
 155 CommandProc CmdCreateSubsidy;
 156 CommandProc CmdCompanyCtrl;
 157 CommandProc CmdCustomNewsItem;
 158 CommandProc CmdCreateGoal;
 159 CommandProc CmdRemoveGoal;
 160 CommandProc CmdSetGoalText;
 161 CommandProc CmdSetGoalProgress;
 162 CommandProc CmdSetGoalCompleted;
 163 CommandProc CmdGoalQuestion;
 164 CommandProc CmdGoalQuestionAnswer;
 165 CommandProc CmdCreateStoryPage;
 166 CommandProc CmdCreateStoryPageElement;
 167 CommandProc CmdUpdateStoryPageElement;
 168 CommandProc CmdSetStoryPageTitle;
 169 CommandProc CmdSetStoryPageDate;
 170 CommandProc CmdShowStoryPage;
 171 CommandProc CmdRemoveStoryPage;
 172 CommandProc CmdRemoveStoryPageElement;
 173 CommandProc CmdScrollViewport;
 174 CommandProc CmdStoryPageButton;
 175
 176 CommandProc CmdLevelLand;
 177
 178 CommandProc CmdBuildSignalTrack;
 179 CommandProc CmdRemoveSignalTrack;
 180
 181 CommandProc CmdSetAutoReplace;
 182
 183 CommandProc CmdCloneVehicle;
 184 CommandProc CmdStartStopVehicle;
 185 CommandProc CmdMassStartStopVehicle;
 186 CommandProc CmdAutoreplaceVehicle;
 187 CommandProc CmdDepotSellAllVehicles;
 188 CommandProc CmdDepotMassAutoReplace;
 189
 190 CommandProc CmdCreateGroup;
 191 CommandProc CmdAlterGroup;
 192 CommandProc CmdDeleteGroup;
 193 CommandProc CmdAddVehicleGroup;
 194 CommandProc CmdAddSharedVehicleGroup;
 195 CommandProc CmdRemoveAllVehiclesGroup;
 196 CommandProc CmdSetGroupReplaceProtection;
 197 CommandProc CmdSetGroupLivery;
 198
 199 CommandProc CmdMoveOrder;
 200 CommandProc CmdChangeTimetable;
 201 CommandProc CmdSetVehicleOnTime;
 202 CommandProc CmdAutofillTimetable;
 203 CommandProc CmdSetTimetableStart;
 204
 205 CommandProc CmdOpenCloseAirport;
 206
 207 #define DEF_CMD(proc, flags, type) {proc, #proc, (CommandFlags)flags, type}
 208
 209 /**
 210  * The master command table
 211  *
 212  * This table contains all possible CommandProc functions with
 213  * the flags which belongs to it. The indices are the same
 214  * as the value from the CMD_* enums.
 215  */
 216 static const Command _command_proc_table[] = {
 217         DEF_CMD(CmdBuildRailroadTrack,       CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_RAILROAD_TRACK
 218         DEF_CMD(CmdRemoveRailroadTrack,                     CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_RAILROAD_TRACK
 219         DEF_CMD(CmdBuildSingleRail,          CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_SINGLE_RAIL
 220         DEF_CMD(CmdRemoveSingleRail,                        CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_SINGLE_RAIL
 221         DEF_CMD(CmdLandscapeClear,                         CMD_DEITY, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_LANDSCAPE_CLEAR
 222         DEF_CMD(CmdBuildBridge,  CMD_DEITY | CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_BRIDGE
 223         DEF_CMD(CmdBuildRailStation,         CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_RAIL_STATION
 224         DEF_CMD(CmdBuildTrainDepot,          CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_TRAIN_DEPOT
 225         DEF_CMD(CmdBuildSingleSignal,                       CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_SIGNALS
 226         DEF_CMD(CmdRemoveSingleSignal,                      CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_SIGNALS
 227         DEF_CMD(CmdTerraformLand,           CMD_ALL_TILES | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_TERRAFORM_LAND
 228         DEF_CMD(CmdBuildObject,              CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_OBJECT
 229         DEF_CMD(CmdBuildTunnel,                 CMD_DEITY | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_TUNNEL
 230         DEF_CMD(CmdRemoveFromRailStation,                          0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_FROM_RAIL_STATION
 231         DEF_CMD(CmdConvertRail,                                    0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_CONVERT_RAILD
 232         DEF_CMD(CmdBuildRailWaypoint,                              0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_RAIL_WAYPOINT
 233         DEF_CMD(CmdRenameWaypoint,                                 0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_WAYPOINT
 234         DEF_CMD(CmdRemoveFromRailWaypoint,                         0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_FROM_RAIL_WAYPOINT
 235
 236         DEF_CMD(CmdBuildRoadStop,            CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_ROAD_STOP
 237         DEF_CMD(CmdRemoveRoadStop,                                 0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_ROAD_STOP
 238         DEF_CMD(CmdBuildLongRoad,CMD_DEITY | CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_LONG_ROAD
 239         DEF_CMD(CmdRemoveLongRoad,            CMD_NO_TEST | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_LONG_ROAD; towns may disallow removing road bits (as they are connected) in test, but in exec they're removed and thus removing is allowed.
 240         DEF_CMD(CmdBuildRoad,    CMD_DEITY | CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_ROAD
 241         DEF_CMD(CmdBuildRoadDepot,           CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_ROAD_DEPOT
 242         DEF_CMD(CmdConvertRoad,                                    0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_CONVERT_ROAD
 243
 244         DEF_CMD(CmdBuildAirport,             CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_AIRPORT
 245         DEF_CMD(CmdBuildDock,                               CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_DOCK
 246         DEF_CMD(CmdBuildShipDepot,                          CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_SHIP_DEPOT
 247         DEF_CMD(CmdBuildBuoy,                               CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_BUOY
 248         DEF_CMD(CmdPlantTree,                               CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_PLANT_TREE
 249
 250         DEF_CMD(CmdBuildVehicle,                       CMD_CLIENT_ID, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_BUILD_VEHICLE
 251         DEF_CMD(CmdSellVehicle,                        CMD_CLIENT_ID, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_SELL_VEHICLE
 252         DEF_CMD(CmdRefitVehicle,                                   0, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_REFIT_VEHICLE
 253         DEF_CMD(CmdSendVehicleToDepot,                             0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_SEND_VEHICLE_TO_DEPOT
 254         DEF_CMD(CmdSetVehicleVisibility,                           0, CMDT_COMPANY_SETTING       ), // CMD_SET_VEHICLE_VISIBILITY
 255
 256         DEF_CMD(CmdMoveRailVehicle,                                0, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_MOVE_RAIL_VEHICLE
 257         DEF_CMD(CmdForceTrainProceed,                              0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_FORCE_TRAIN_PROCEED
 258         DEF_CMD(CmdReverseTrainDirection,                          0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_REVERSE_TRAIN_DIRECTION
 259
 260         DEF_CMD(CmdClearOrderBackup,                   CMD_CLIENT_ID, CMDT_SERVER_SETTING        ), // CMD_CLEAR_ORDER_BACKUP
 261         DEF_CMD(CmdModifyOrder,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_MODIFY_ORDER
 262         DEF_CMD(CmdSkipToOrder,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_SKIP_TO_ORDER
 263         DEF_CMD(CmdDeleteOrder,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_DELETE_ORDER
 264         DEF_CMD(CmdInsertOrder,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_INSERT_ORDER
 265
 266         DEF_CMD(CmdChangeServiceInt,                               0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_CHANGE_SERVICE_INT
 267
 268         DEF_CMD(CmdBuildIndustry,                          CMD_DEITY, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_INDUSTRY
 269         DEF_CMD(CmdIndustryCtrl,            CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_INDUSTRY_CTRL
 270
 271         DEF_CMD(CmdSetCompanyManagerFace,                          0, CMDT_OTHER_MANAGEMENT      ), // CMD_SET_COMPANY_MANAGER_FACE
 272         DEF_CMD(CmdSetCompanyColour,                               0, CMDT_OTHER_MANAGEMENT      ), // CMD_SET_COMPANY_COLOUR
 273
 274         DEF_CMD(CmdIncreaseLoan,                                   0, CMDT_MONEY_MANAGEMENT      ), // CMD_INCREASE_LOAN
 275         DEF_CMD(CmdDecreaseLoan,                                   0, CMDT_MONEY_MANAGEMENT      ), // CMD_DECREASE_LOAN
 276
 277         DEF_CMD(CmdWantEnginePreview,                              0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_WANT_ENGINE_PREVIEW
 278         DEF_CMD(CmdEngineCtrl,                             CMD_DEITY, CMDT_VEHICLE_MANAGEMENT    ), // CMD_ENGINE_CTRL
 279
 280         DEF_CMD(CmdRenameVehicle,                                  0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_VEHICLE
 281         DEF_CMD(CmdRenameEngine,                          CMD_SERVER, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_ENGINE
 282
 283         DEF_CMD(CmdRenameCompany,                                  0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_COMPANY
 284         DEF_CMD(CmdRenamePresident,                                0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_PRESIDENT
 285
 286         DEF_CMD(CmdRenameStation,                                  0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_STATION
 287         DEF_CMD(CmdRenameDepot,                                    0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_DEPOT
 288
 289         DEF_CMD(CmdPlaceSign,                              CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_PLACE_SIGN
 290         DEF_CMD(CmdRenameSign,                             CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_SIGN
 291
 292         DEF_CMD(CmdTurnRoadVeh,                                    0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_TURN_ROADVEH
 293
 294         DEF_CMD(CmdPause,                    CMD_SERVER | CMD_NO_EST, CMDT_SERVER_SETTING        ), // CMD_PAUSE
 295
 296         DEF_CMD(CmdBuyShareInCompany,                              0, CMDT_MONEY_MANAGEMENT      ), // CMD_BUY_SHARE_IN_COMPANY
 297         DEF_CMD(CmdSellShareInCompany,                             0, CMDT_MONEY_MANAGEMENT      ), // CMD_SELL_SHARE_IN_COMPANY
 298         DEF_CMD(CmdBuyCompany,                                     0, CMDT_MONEY_MANAGEMENT      ), // CMD_BUY_COMANY
 299
 300         DEF_CMD(CmdFoundTown,                CMD_DEITY | CMD_NO_TEST, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_FOUND_TOWN; founding random town can fail only in exec run
 301         DEF_CMD(CmdRenameTown,                CMD_DEITY | CMD_SERVER, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_TOWN
 302         DEF_CMD(CmdDoTownAction,                                   0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_DO_TOWN_ACTION
 303         DEF_CMD(CmdTownCargoGoal,                          CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_TOWN_CARGO_GOAL
 304         DEF_CMD(CmdTownGrowthRate,                         CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_TOWN_GROWTH_RATE
 305         DEF_CMD(CmdTownRating,                             CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_TOWN_RATING
 306         DEF_CMD(CmdTownSetText,             CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_TOWN_SET_TEXT
 307         DEF_CMD(CmdExpandTown,                             CMD_DEITY, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_EXPAND_TOWN
 308         DEF_CMD(CmdDeleteTown,                           CMD_OFFLINE, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_DELETE_TOWN
 309
 310         DEF_CMD(CmdOrderRefit,                                     0, CMDT_ROUTE_MANAGEMENT      ), // CMD_ORDER_REFIT
 311         DEF_CMD(CmdCloneOrder,                                     0, CMDT_ROUTE_MANAGEMENT      ), // CMD_CLONE_ORDER
 312
 313         DEF_CMD(CmdClearArea,                            CMD_NO_TEST, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_CLEAR_AREA; destroying multi-tile houses makes town rating differ between test and execution
 314
 315         DEF_CMD(CmdMoneyCheat,                           CMD_OFFLINE, CMDT_CHEAT                 ), // CMD_MONEY_CHEAT
 316         DEF_CMD(CmdChangeBankBalance,                      CMD_DEITY, CMDT_MONEY_MANAGEMENT      ), // CMD_CHANGE_BANK_BALANCE
 317         DEF_CMD(CmdBuildCanal,                              CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_CANAL
 318         DEF_CMD(CmdCreateSubsidy,                          CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_CREATE_SUBSIDY
 319         DEF_CMD(CmdCompanyCtrl, CMD_SPECTATOR | CMD_CLIENT_ID | CMD_NO_EST, CMDT_SERVER_SETTING  ), // CMD_COMPANY_CTRL
 320         DEF_CMD(CmdCustomNewsItem,          CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_CUSTOM_NEWS_ITEM
 321         DEF_CMD(CmdCreateGoal,              CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_CREATE_GOAL
 322         DEF_CMD(CmdRemoveGoal,                             CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_REMOVE_GOAL
 323         DEF_CMD(CmdSetGoalText,             CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_SET_GOAL_TEXT
 324         DEF_CMD(CmdSetGoalProgress,         CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_SET_GOAL_PROGRESS
 325         DEF_CMD(CmdSetGoalCompleted,        CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_SET_GOAL_COMPLETED
 326         DEF_CMD(CmdGoalQuestion,            CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_GOAL_QUESTION
 327         DEF_CMD(CmdGoalQuestionAnswer,                     CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_GOAL_QUESTION_ANSWER
 328         DEF_CMD(CmdCreateStoryPage,         CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_CREATE_STORY_PAGE
 329         DEF_CMD(CmdCreateStoryPageElement,  CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_CREATE_STORY_PAGE_ELEMENT
 330         DEF_CMD(CmdUpdateStoryPageElement,  CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_UPDATE_STORY_PAGE_ELEMENT
 331         DEF_CMD(CmdSetStoryPageTitle,       CMD_STR_CTRL | CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_SET_STORY_PAGE_TITLE
 332         DEF_CMD(CmdSetStoryPageDate,                       CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_SET_STORY_PAGE_DATE
 333         DEF_CMD(CmdShowStoryPage,                          CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_SHOW_STORY_PAGE
 334         DEF_CMD(CmdRemoveStoryPage,                        CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_REMOVE_STORY_PAGE
 335         DEF_CMD(CmdRemoveStoryPageElement,                 CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_REMOVE_STORY_ELEMENT_PAGE
 336         DEF_CMD(CmdScrollViewport,                         CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_SCROLL_VIEWPORT
 337         DEF_CMD(CmdStoryPageButton,                        CMD_DEITY, CMDT_OTHER_MANAGEMENT      ), // CMD_STORY_PAGE_BUTTON
 338
 339         DEF_CMD(CmdLevelLand, CMD_ALL_TILES | CMD_NO_TEST | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_LEVEL_LAND; test run might clear tiles multiple times, in execution that only happens once
 340
 341         DEF_CMD(CmdBuildLock,                               CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_LOCK
 342
 343         DEF_CMD(CmdBuildSignalTrack,                        CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_SIGNAL_TRACK
 344         DEF_CMD(CmdRemoveSignalTrack,                       CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_SIGNAL_TRACK
 345
 346         DEF_CMD(CmdGiveMoney,                                      0, CMDT_MONEY_MANAGEMENT      ), // CMD_GIVE_MONEY
 347         DEF_CMD(CmdChangeSetting,                         CMD_SERVER, CMDT_SERVER_SETTING        ), // CMD_CHANGE_SETTING
 348         DEF_CMD(CmdChangeCompanySetting,                           0, CMDT_COMPANY_SETTING       ), // CMD_CHANGE_COMPANY_SETTING
 349         DEF_CMD(CmdSetAutoReplace,                                 0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_SET_AUTOREPLACE
 350         DEF_CMD(CmdCloneVehicle,                         CMD_NO_TEST, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_CLONE_VEHICLE; NewGRF callbacks influence building and refitting making it impossible to correctly estimate the cost
 351         DEF_CMD(CmdStartStopVehicle,                               0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_START_STOP_VEHICLE
 352         DEF_CMD(CmdMassStartStopVehicle,                           0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_MASS_START_STOP
 353         DEF_CMD(CmdAutoreplaceVehicle,                             0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_AUTOREPLACE_VEHICLE
 354         DEF_CMD(CmdDepotSellAllVehicles,                           0, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_DEPOT_SELL_ALL_VEHICLES
 355         DEF_CMD(CmdDepotMassAutoReplace,                           0, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_DEPOT_MASS_AUTOREPLACE
 356         DEF_CMD(CmdCreateGroup,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_CREATE_GROUP
 357         DEF_CMD(CmdDeleteGroup,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_DELETE_GROUP
 358         DEF_CMD(CmdAlterGroup,                                     0, CMDT_OTHER_MANAGEMENT      ), // CMD_ALTER_GROUP
 359         DEF_CMD(CmdAddVehicleGroup,                                0, CMDT_ROUTE_MANAGEMENT      ), // CMD_ADD_VEHICLE_GROUP
 360         DEF_CMD(CmdAddSharedVehicleGroup,                          0, CMDT_ROUTE_MANAGEMENT      ), // CMD_ADD_SHARE_VEHICLE_GROUP
 361         DEF_CMD(CmdRemoveAllVehiclesGroup,                         0, CMDT_ROUTE_MANAGEMENT      ), // CMD_REMOVE_ALL_VEHICLES_GROUP
 362         DEF_CMD(CmdSetGroupReplaceProtection,                      0, CMDT_ROUTE_MANAGEMENT      ), // CMD_SET_GROUP_REPLACE_PROTECTION
 363         DEF_CMD(CmdSetGroupLivery,                                 0, CMDT_ROUTE_MANAGEMENT      ), // CMD_SET_GROUP_LIVERY
 364         DEF_CMD(CmdMoveOrder,                                      0, CMDT_ROUTE_MANAGEMENT      ), // CMD_MOVE_ORDER
 365         DEF_CMD(CmdChangeTimetable,                                0, CMDT_ROUTE_MANAGEMENT      ), // CMD_CHANGE_TIMETABLE
 366         DEF_CMD(CmdSetVehicleOnTime,                               0, CMDT_ROUTE_MANAGEMENT      ), // CMD_SET_VEHICLE_ON_TIME
 367         DEF_CMD(CmdAutofillTimetable,                              0, CMDT_ROUTE_MANAGEMENT      ), // CMD_AUTOFILL_TIMETABLE
 368         DEF_CMD(CmdSetTimetableStart,                              0, CMDT_ROUTE_MANAGEMENT      ), // CMD_SET_TIMETABLE_START
 369
 370         DEF_CMD(CmdOpenCloseAirport,                               0, CMDT_ROUTE_MANAGEMENT      ), // CMD_OPEN_CLOSE_AIRPORT
 371 };
 372
 373 /*!
 374  * This function range-checks a cmd, and checks if the cmd is not nullptr
 375  *
 376  * @param cmd The integer value of a command
 377  * @return true if the command is valid (and got a CommandProc function)
 378  */
 379 bool IsValidCommand(uint32 cmd)
 380 {
 381         cmd &= CMD_ID_MASK;
 382
 383         return cmd < lengthof(_command_proc_table) && _command_proc_table[cmd].proc != nullptr;
 384 }
 385
 386 /*!
 387  * This function mask the parameter with CMD_ID_MASK and returns
 388  * the flags which belongs to the given command.
 389  *
 390  * @param cmd The integer value of the command
 391  * @return The flags for this command
 392  */
 393 CommandFlags GetCommandFlags(uint32 cmd)
 394 {
 395         assert(IsValidCommand(cmd));
 396
 397         return _command_proc_table[cmd & CMD_ID_MASK].flags;
 398 }
 399
 400 /*!
 401  * This function mask the parameter with CMD_ID_MASK and returns
 402  * the name which belongs to the given command.
 403  *
 404  * @param cmd The integer value of the command
 405  * @return The name for this command
 406  */
 407 const char *GetCommandName(uint32 cmd)
 408 {
 409         assert(IsValidCommand(cmd));
 410
 411         return _command_proc_table[cmd & CMD_ID_MASK].name;
 412 }
 413
 414 /**
 415  * Returns whether the command is allowed while the game is paused.
 416  * @param cmd The command to check.
 417  * @return True if the command is allowed while paused, false otherwise.
 418  */
 419 bool IsCommandAllowedWhilePaused(uint32 cmd)
 420 {
 421         /* Lookup table for the command types that are allowed for a given pause level setting. */
 422         static const int command_type_lookup[] = {
 423                 CMDPL_ALL_ACTIONS,     ///< CMDT_LANDSCAPE_CONSTRUCTION
 424                 CMDPL_NO_LANDSCAPING,  ///< CMDT_VEHICLE_CONSTRUCTION
 425                 CMDPL_NO_LANDSCAPING,  ///< CMDT_MONEY_MANAGEMENT
 426                 CMDPL_NO_CONSTRUCTION, ///< CMDT_VEHICLE_MANAGEMENT
 427                 CMDPL_NO_CONSTRUCTION, ///< CMDT_ROUTE_MANAGEMENT
 428                 CMDPL_NO_CONSTRUCTION, ///< CMDT_OTHER_MANAGEMENT
 429                 CMDPL_NO_CONSTRUCTION, ///< CMDT_COMPANY_SETTING
 430                 CMDPL_NO_ACTIONS,      ///< CMDT_SERVER_SETTING
 431                 CMDPL_NO_ACTIONS,      ///< CMDT_CHEAT
 432         };
 433         static_assert(lengthof(command_type_lookup) == CMDT_END);
 434
 435         assert(IsValidCommand(cmd));
 436         return _game_mode == GM_EDITOR || command_type_lookup[_command_proc_table[cmd & CMD_ID_MASK].type] <= _settings_game.construction.command_pause_level;
 437 }
 438
 439
 440 static int _docommand_recursive = 0;
 441
 442 /**
 443  * Shorthand for calling the long DoCommand with a container.
 444  *
 445  * @param container Container with (almost) all information
 446  * @param flags Flags for the command and how to execute the command
 447  * @see CommandProc
 448  * @return the cost
 449  */
 450 CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
 451 {
 452         return DoCommand(container->tile, container->p1, container->p2, flags, container->cmd & CMD_ID_MASK, container->text);
 453 }
 454
 455 /*!
 456  * This function executes a given command with the parameters from the #CommandProc parameter list.
 457  * Depending on the flags parameter it execute or test a command.
 458  *
 459  * @param tile The tile to apply the command on (for the #CommandProc)
 460  * @param p1 Additional data for the command (for the #CommandProc)
 461  * @param p2 Additional data for the command (for the #CommandProc)
 462  * @param flags Flags for the command and how to execute the command
 463  * @param cmd The command-id to execute (a value of the CMD_* enums)
 464  * @param text The text to pass
 465  * @see CommandProc
 466  * @return the cost
 467  */
 468 CommandCost DoCommand(TileIndex tile, uint32 p1, uint32 p2, DoCommandFlag flags, uint32 cmd, const char *text)
 469 {
 470         CommandCost res;
 471
 472         /* Do not even think about executing out-of-bounds tile-commands */
 473         if (tile != 0 && (tile >= MapSize() || (!IsValidTile(tile) && (flags & DC_ALL_TILES) == 0))) return CMD_ERROR;
 474
 475         /* Chop of any CMD_MSG or other flags; we don't need those here */
 476         CommandProc *proc = _command_proc_table[cmd & CMD_ID_MASK].proc;
 477
 478         _docommand_recursive++;
 479
 480         /* only execute the test call if it's toplevel, or we're not execing. */
 481         if (_docommand_recursive == 1 || !(flags & DC_EXEC) ) {
 482                 if (_docommand_recursive == 1) _cleared_object_areas.clear();
 483                 SetTownRatingTestMode(true);
 484                 res = proc(tile, flags & ~DC_EXEC, p1, p2, text);
 485                 SetTownRatingTestMode(false);
 486                 if (res.Failed()) {
 487                         goto error;
 488                 }
 489
 490                 if (_docommand_recursive == 1 &&
 491                                 !(flags & DC_QUERY_COST) &&
 492                                 !(flags & DC_BANKRUPT) &&
 493                                 !CheckCompanyHasMoney(res)) { // CheckCompanyHasMoney() modifies 'res' to an error if it fails.
 494                         goto error;
 495                 }
 496
 497                 if (!(flags & DC_EXEC)) {
 498                         _docommand_recursive--;
 499                         return res;
 500                 }
 501         }
 502
 503         /* Execute the command here. All cost-relevant functions set the expenses type
 504          * themselves to the cost object at some point */
 505         if (_docommand_recursive == 1) _cleared_object_areas.clear();
 506         res = proc(tile, flags, p1, p2, text);
 507         if (res.Failed()) {
 508 error:
 509                 _docommand_recursive--;
 510                 return res;
 511         }
 512
 513         /* if toplevel, subtract the money. */
 514         if (--_docommand_recursive == 0 && !(flags & DC_BANKRUPT)) {
 515                 SubtractMoneyFromCompany(res);
 516         }
 517
 518         return res;
 519 }
 520
 521 /*!
 522  * This functions returns the money which can be used to execute a command.
 523  * This is either the money of the current company or INT64_MAX if there
 524  * is no such a company "at the moment" like the server itself.
 525  *
 526  * @return The available money of a company or INT64_MAX
 527  */
 528 Money GetAvailableMoneyForCommand()
 529 {
 530         CompanyID company = _current_company;
 531         if (!Company::IsValidID(company)) return INT64_MAX;
 532         return Company::Get(company)->money;
 533 }
 534
 535 /**
 536  * Shortcut for the long DoCommandP when having a container with the data.
 537  * @param container the container with information.
 538  * @param my_cmd indicator if the command is from a company or server (to display error messages for a user)
 539  * @return true if the command succeeded, else false
 540  */
 541 bool DoCommandP(const CommandContainer *container, bool my_cmd)
 542 {
 543         return DoCommandP(container->tile, container->p1, container->p2, container->cmd, container->callback, container->text, my_cmd);
 544 }
 545
 546 /*!
 547  * Toplevel network safe docommand function for the current company. Must not be called recursively.
 548  * The callback is called when the command succeeded or failed. The parameters
 549  * \a tile, \a p1, and \a p2 are from the #CommandProc function. The parameter \a cmd is the command to execute.
 550  * The parameter \a my_cmd is used to indicate if the command is from a company or the server.
 551  *
 552  * @param tile The tile to perform a command on (see #CommandProc)
 553  * @param p1 Additional data for the command (see #CommandProc)
 554  * @param p2 Additional data for the command (see #CommandProc)
 555  * @param cmd The command to execute (a CMD_* value)
 556  * @param callback A callback function to call after the command is finished
 557  * @param text The text to pass
 558  * @param my_cmd indicator if the command is from a company or server (to display error messages for a user)
 559  * @return \c true if the command succeeded, else \c false.
 560  */
 561 bool DoCommandP(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const char *text, bool my_cmd)
 562 {
 563         /* Cost estimation is generally only done when the
 564          * local user presses shift while doing something.
 565          * However, in case of incoming network commands,
 566          * map generation or the pause button we do want
 567          * to execute. */
 568         bool estimate_only = _shift_pressed && IsLocalCompany() &&
 569                         !_generating_world &&
 570                         !(cmd & CMD_NETWORK_COMMAND) &&
 571                         !(GetCommandFlags(cmd) & CMD_NO_EST);
 572
 573         /* We're only sending the command, so don't do
 574          * fancy things for 'success'. */
 575         bool only_sending = _networking && !(cmd & CMD_NETWORK_COMMAND);
 576
 577         /* Where to show the message? */
 578         int x = TileX(tile) * TILE_SIZE;
 579         int y = TileY(tile) * TILE_SIZE;
 580
 581         if (_pause_mode != PM_UNPAUSED && !IsCommandAllowedWhilePaused(cmd) && !estimate_only) {
 582                 ShowErrorMessage(GB(cmd, 16, 16), STR_ERROR_NOT_ALLOWED_WHILE_PAUSED, WL_INFO, x, y);
 583                 return false;
 584         }
 585
 586         /* Only set p2 when the command does not come from the network. */
 587         if (!(cmd & CMD_NETWORK_COMMAND) && GetCommandFlags(cmd) & CMD_CLIENT_ID && p2 == 0) p2 = CLIENT_ID_SERVER;
 588
 589         CommandCost res = DoCommandPInternal(tile, p1, p2, cmd, callback, text, my_cmd, estimate_only);
 590         if (res.Failed()) {
 591                 /* Only show the error when it's for us. */
 592                 StringID error_part1 = GB(cmd, 16, 16);
 593                 if (estimate_only || (IsLocalCompany() && error_part1 != 0 && my_cmd)) {
 594                         ShowErrorMessage(error_part1, res.GetErrorMessage(), WL_INFO, x, y, res.GetTextRefStackGRF(), res.GetTextRefStackSize(), res.GetTextRefStack());
 595                 }
 596         } else if (estimate_only) {
 597                 ShowEstimatedCostOrIncome(res.GetCost(), x, y);
 598         } else if (!only_sending && res.GetCost() != 0 && tile != 0 && IsLocalCompany() && _game_mode != GM_EDITOR) {
 599                 /* Only show the cost animation when we did actually
 600                  * execute the command, i.e. we're not sending it to
 601                  * the server, when it has cost the local company
 602                  * something. Furthermore in the editor there is no
 603                  * concept of cost, so don't show it there either. */
 604                 ShowCostOrIncomeAnimation(x, y, GetSlopePixelZ(x, y), res.GetCost());
 605         }
 606
 607         if (!estimate_only && !only_sending && callback != nullptr) {
 608                 callback(res, tile, p1, p2, cmd);
 609         }
 610
 611         return res.Succeeded();
 612 }
 613
 614
 615 /**
 616  * Helper to deduplicate the code for returning.
 617  * @param cmd   the command cost to return.
 618  */
 619 #define return_dcpi(cmd) { _docommand_recursive = 0; return cmd; }
 620
 621 /*!
 622  * Helper function for the toplevel network safe docommand function for the current company.
 623  *
 624  * @param tile The tile to perform a command on (see #CommandProc)
 625  * @param p1 Additional data for the command (see #CommandProc)
 626  * @param p2 Additional data for the command (see #CommandProc)
 627  * @param cmd The command to execute (a CMD_* value)
 628  * @param callback A callback function to call after the command is finished
 629  * @param text The text to pass
 630  * @param my_cmd indicator if the command is from a company or server (to display error messages for a user)
 631  * @param estimate_only whether to give only the estimate or also execute the command
 632  * @return the command cost of this function.
 633  */
 634 CommandCost DoCommandPInternal(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const char *text, bool my_cmd, bool estimate_only)
 635 {
 636         /* Prevent recursion; it gives a mess over the network */
 637         assert(_docommand_recursive == 0);
 638         _docommand_recursive = 1;
 639
 640         /* Reset the state. */
 641         _additional_cash_required = 0;
 642
 643         /* Get pointer to command handler */
 644         byte cmd_id = cmd & CMD_ID_MASK;
 645         assert(cmd_id < lengthof(_command_proc_table));
 646
 647         CommandProc *proc = _command_proc_table[cmd_id].proc;
 648         /* Shouldn't happen, but you never know when someone adds
 649          * NULLs to the _command_proc_table. */
 650         assert(proc != nullptr);
 651
 652         /* Command flags are used internally */
 653         CommandFlags cmd_flags = GetCommandFlags(cmd);
 654         /* Flags get send to the DoCommand */
 655         DoCommandFlag flags = CommandFlagsToDCFlags(cmd_flags);
 656
 657         /* Make sure p2 is properly set to a ClientID. */
 658         assert(!(cmd_flags & CMD_CLIENT_ID) || p2 != 0);
 659
 660         /* Do not even think about executing out-of-bounds tile-commands */
 661         if (tile != 0 && (tile >= MapSize() || (!IsValidTile(tile) && (cmd_flags & CMD_ALL_TILES) == 0))) return_dcpi(CMD_ERROR);
 662
 663         /* Always execute server and spectator commands as spectator */
 664         bool exec_as_spectator = (cmd_flags & (CMD_SPECTATOR | CMD_SERVER)) != 0;
 665
 666         /* If the company isn't valid it may only do server command or start a new company!
 667          * The server will ditch any server commands a client sends to it, so effectively
 668          * this guards the server from executing functions for an invalid company. */
 669         if (_game_mode == GM_NORMAL && !exec_as_spectator && !Company::IsValidID(_current_company) && !(_current_company == OWNER_DEITY && (cmd_flags & CMD_DEITY) != 0)) {
 670                 return_dcpi(CMD_ERROR);
 671         }
 672
 673         Backup<CompanyID> cur_company(_current_company, FILE_LINE);
 674         if (exec_as_spectator) cur_company.Change(COMPANY_SPECTATOR);
 675
 676         bool test_and_exec_can_differ = (cmd_flags & CMD_NO_TEST) != 0;
 677
 678         /* Test the command. */
 679         _cleared_object_areas.clear();
 680         SetTownRatingTestMode(true);
 681         BasePersistentStorageArray::SwitchMode(PSM_ENTER_TESTMODE);
 682         CommandCost res = proc(tile, flags, p1, p2, text);
 683         BasePersistentStorageArray::SwitchMode(PSM_LEAVE_TESTMODE);
 684         SetTownRatingTestMode(false);
 685
 686         /* Make sure we're not messing things up here. */
 687         assert(exec_as_spectator ? _current_company == COMPANY_SPECTATOR : cur_company.Verify());
 688
 689         /* If the command fails, we're doing an estimate
 690          * or the player does not have enough money
 691          * (unless it's a command where the test and
 692          * execution phase might return different costs)
 693          * we bail out here. */
 694         if (res.Failed() || estimate_only ||
 695                         (!test_and_exec_can_differ && !CheckCompanyHasMoney(res))) {
 696                 if (!_networking || _generating_world || (cmd & CMD_NETWORK_COMMAND) != 0) {
 697                         /* Log the failed command as well. Just to be able to be find
 698                          * causes of desyncs due to bad command test implementations. */
 699                         DEBUG(desync, 1, "cmdf: %08x; %02x; %02x; %06x; %08x; %08x; %08x; \"%s\" (%s)", _date, _date_fract, (int)_current_company, tile, p1, p2, cmd & ~CMD_NETWORK_COMMAND, text, GetCommandName(cmd));
 700                 }
 701                 cur_company.Restore();
 702                 return_dcpi(res);
 703         }
 704
 705         /*
 706          * If we are in network, and the command is not from the network
 707          * send it to the command-queue and abort execution
 708          */
 709         if (_networking && !_generating_world && !(cmd & CMD_NETWORK_COMMAND)) {
 710                 NetworkSendCommand(tile, p1, p2, cmd & ~CMD_FLAGS_MASK, callback, text, _current_company);
 711                 cur_company.Restore();
 712
 713                 /* Don't return anything special here; no error, no costs.
 714                  * This way it's not handled by DoCommand and only the
 715                  * actual execution of the command causes messages. Also
 716                  * reset the storages as we've not executed the command. */
 717                 return_dcpi(CommandCost());
 718         }
 719         DEBUG(desync, 1, "cmd: %08x; %02x; %02x; %06x; %08x; %08x; %08x; \"%s\" (%s)", _date, _date_fract, (int)_current_company, tile, p1, p2, cmd & ~CMD_NETWORK_COMMAND, text, GetCommandName(cmd));
 720
 721         /* Actually try and execute the command. If no cost-type is given
 722          * use the construction one */
 723         _cleared_object_areas.clear();
 724         BasePersistentStorageArray::SwitchMode(PSM_ENTER_COMMAND);
 725         CommandCost res2 = proc(tile, flags | DC_EXEC, p1, p2, text);
 726         BasePersistentStorageArray::SwitchMode(PSM_LEAVE_COMMAND);
 727
 728         if (cmd_id == CMD_COMPANY_CTRL) {
 729                 cur_company.Trash();
 730                 /* We are a new company                  -> Switch to new local company.
 731                  * We were closed down                   -> Switch to spectator
 732                  * Some other company opened/closed down -> The outside function will switch back */
 733                 _current_company = _local_company;
 734         } else {
 735                 /* Make sure nothing bad happened, like changing the current company. */
 736                 assert(exec_as_spectator ? _current_company == COMPANY_SPECTATOR : cur_company.Verify());
 737                 cur_company.Restore();
 738         }
 739
 740         /* If the test and execution can differ we have to check the
 741          * return of the command. Otherwise we can check whether the
 742          * test and execution have yielded the same result,
 743          * i.e. cost and error state are the same. */
 744         if (!test_and_exec_can_differ) {
 745                 assert(res.GetCost() == res2.GetCost() && res.Failed() == res2.Failed()); // sanity check
 746         } else if (res2.Failed()) {
 747                 return_dcpi(res2);
 748         }
 749
 750         /* If we're needing more money and we haven't done
 751          * anything yet, ask for the money! */
 752         if (_additional_cash_required != 0 && res2.GetCost() == 0) {
 753                 /* It could happen we removed rail, thus gained money, and deleted something else.
 754                  * So make sure the signal buffer is empty even in this case */
 755                 UpdateSignalsInBuffer();
 756                 SetDParam(0, _additional_cash_required);
 757                 return_dcpi(CommandCost(STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY));
 758         }
 759
 760         /* update last build coordinate of company. */
 761         if (tile != 0) {
 762                 Company *c = Company::GetIfValid(_current_company);
 763                 if (c != nullptr) c->last_build_coordinate = tile;
 764         }
 765
 766         SubtractMoneyFromCompany(res2);
 767
 768         /* update signals if needed */
 769         UpdateSignalsInBuffer();
 770
 771         return_dcpi(res2);
 772 }
 773 #undef return_dcpi
 774
 775
 776 /**
 777  * Adds the cost of the given command return value to this cost.
 778  * Also takes a possible error message when it is set.
 779  * @param ret The command to add the cost of.
 780  */
 781 void CommandCost::AddCost(const CommandCost &ret)
 782 {
 783         this->AddCost(ret.cost);
 784         if (this->success && !ret.success) {
 785                 this->message = ret.message;
 786                 this->success = false;
 787         }
 788 }
 789
 790 /**
 791  * Values to put on the #TextRefStack for the error message.
 792  * There is only one static instance of the array, just like there is only one
 793  * instance of normal DParams.
 794  */
 795 uint32 CommandCost::textref_stack[16];
 796
 797 /**
 798  * Activate usage of the NewGRF #TextRefStack for the error message.
 799  * @param grffile NewGRF that provides the #TextRefStack
 800  * @param num_registers number of entries to copy from the temporary NewGRF registers
 801  */
 802 void CommandCost::UseTextRefStack(const GRFFile *grffile, uint num_registers)
 803 {
 804         extern TemporaryStorageArray<int32, 0x110> _temp_store;
 805
 806         assert(num_registers < lengthof(textref_stack));
 807         this->textref_stack_grffile = grffile;
 808         this->textref_stack_size = num_registers;
 809         for (uint i = 0; i < num_registers; i++) {
 810                 textref_stack[i] = _temp_store.GetValue(0x100 + i);
 811         }
 812 }