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 #include "autoreplace_cmd.h"
  28 #include "company_cmd.h"
  29 #include "depot_cmd.h"
  30 #include "economy_cmd.h"
  31 #include "engine_cmd.h"
  32 #include "goal_cmd.h"
  33 #include "group_cmd.h"
  34 #include "industry_cmd.h"
  35 #include "landscape_cmd.h"
  36 #include "misc_cmd.h"
  37 #include "news_cmd.h"
  38 #include "object_cmd.h"
  39 #include "order_cmd.h"
  40 #include "rail_cmd.h"
  41 #include "road_cmd.h"
  42 #include "roadveh_cmd.h"
  43 #include "settings_cmd.h"
  44 #include "signs_cmd.h"
  45 #include "station_cmd.h"
  46 #include "story_cmd.h"
  47 #include "subsidy_cmd.h"
  48 #include "terraform_cmd.h"
  49 #include "timetable_cmd.h"
  50 #include "town_cmd.h"
  51 #include "train_cmd.h"
  52 #include "tree_cmd.h"
  53 #include "tunnelbridge_cmd.h"
  54 #include "vehicle_cmd.h"
  55 #include "viewport_cmd.h"
  56 #include "water_cmd.h"
  57 #include "waypoint_cmd.h"
  58 #include "misc/endian_buffer.hpp"
  59 #include "string_func.h"
  60
  61 #include <array>
  62
  63 #include "table/strings.h"
  64
  65 #include "safeguards.h"
  66
  67
  68 int RecursiveCommandCounter::_counter = 0;
  69
  70
  71 /**
  72  * Define a command with the flags which belongs to it.
  73  *
  74  * This struct connects a command handler function with the flags created with
  75  * the #CMD_AUTO, #CMD_OFFLINE and #CMD_SERVER values.
  76  */
  77 struct CommandInfo {
  78         const char *name;   ///< A human readable name for the procedure
  79         CommandFlags flags; ///< The (command) flags to that apply to this command
  80         CommandType type;   ///< The type of command.
  81 };
  82 /* Helpers to generate the master command table from the command traits. */
  83 template <typename T>
  84 inline constexpr CommandInfo CommandFromTrait() noexcept { return { T::name, T::flags, T::type }; };
  85
  86 template<typename T, T... i>
  87 inline constexpr auto MakeCommandsFromTraits(std::integer_sequence<T, i...>) noexcept {
  88         return std::array<CommandInfo, sizeof...(i)>{{ CommandFromTrait<CommandTraits<static_cast<Commands>(i)>>()... }};
  89 }
  90
  91 /**
  92  * The master command table
  93  *
  94  * This table contains all possible CommandProc functions with
  95  * the flags which belongs to it. The indices are the same
  96  * as the value from the CMD_* enums.
  97  */
  98 static constexpr auto _command_proc_table = MakeCommandsFromTraits(std::make_integer_sequence<std::underlying_type_t<Commands>, CMD_END>{});
  99
 100
 101 /*!
 102  * This function range-checks a cmd.
 103  *
 104  * @param cmd The integer value of a command
 105  * @return true if the command is valid (and got a CommandProc function)
 106  */
 107 bool IsValidCommand(Commands cmd)
 108 {
 109         return cmd < _command_proc_table.size();
 110 }
 111
 112 /*!
 113  * This function mask the parameter with CMD_ID_MASK and returns
 114  * the flags which belongs to the given command.
 115  *
 116  * @param cmd The integer value of the command
 117  * @return The flags for this command
 118  */
 119 CommandFlags GetCommandFlags(Commands cmd)
 120 {
 121         assert(IsValidCommand(cmd));
 122
 123         return _command_proc_table[cmd].flags;
 124 }
 125
 126 /*!
 127  * This function mask the parameter with CMD_ID_MASK and returns
 128  * the name which belongs to the given command.
 129  *
 130  * @param cmd The integer value of the command
 131  * @return The name for this command
 132  */
 133 const char *GetCommandName(Commands cmd)
 134 {
 135         assert(IsValidCommand(cmd));
 136
 137         return _command_proc_table[cmd].name;
 138 }
 139
 140 /**
 141  * Returns whether the command is allowed while the game is paused.
 142  * @param cmd The command to check.
 143  * @return True if the command is allowed while paused, false otherwise.
 144  */
 145 bool IsCommandAllowedWhilePaused(Commands cmd)
 146 {
 147         /* Lookup table for the command types that are allowed for a given pause level setting. */
 148         static const int command_type_lookup[] = {
 149                 CMDPL_ALL_ACTIONS,     ///< CMDT_LANDSCAPE_CONSTRUCTION
 150                 CMDPL_NO_LANDSCAPING,  ///< CMDT_VEHICLE_CONSTRUCTION
 151                 CMDPL_NO_LANDSCAPING,  ///< CMDT_MONEY_MANAGEMENT
 152                 CMDPL_NO_CONSTRUCTION, ///< CMDT_VEHICLE_MANAGEMENT
 153                 CMDPL_NO_CONSTRUCTION, ///< CMDT_ROUTE_MANAGEMENT
 154                 CMDPL_NO_CONSTRUCTION, ///< CMDT_OTHER_MANAGEMENT
 155                 CMDPL_NO_CONSTRUCTION, ///< CMDT_COMPANY_SETTING
 156                 CMDPL_NO_ACTIONS,      ///< CMDT_SERVER_SETTING
 157                 CMDPL_NO_ACTIONS,      ///< CMDT_CHEAT
 158         };
 159         static_assert(lengthof(command_type_lookup) == CMDT_END);
 160
 161         assert(IsValidCommand(cmd));
 162         return _game_mode == GM_EDITOR || command_type_lookup[_command_proc_table[cmd].type] <= _settings_game.construction.command_pause_level;
 163 }
 164
 165 /*!
 166  * This functions returns the money which can be used to execute a command.
 167  * This is either the money of the current company or INT64_MAX if there
 168  * is no such a company "at the moment" like the server itself.
 169  *
 170  * @return The available money of a company or INT64_MAX
 171  */
 172 Money GetAvailableMoneyForCommand()
 173 {
 174         CompanyID company = _current_company;
 175         if (!Company::IsValidID(company)) return INT64_MAX;
 176         return Company::Get(company)->money;
 177 }
 178
 179
 180 /**
 181  * Prepare for calling a command proc.
 182  * @param top_level Top level of command execution, i.e. command from a command.
 183  * @param test Test run of command?
 184  */
 185 void CommandHelperBase::InternalDoBefore(bool top_level, bool test)
 186 {
 187         if (top_level) _cleared_object_areas.clear();
 188         if (test) SetTownRatingTestMode(true);
 189 }
 190
 191 /**
 192  * Process result after calling a command proc.
 193  * @param[in,out] res Command result, may be modified.
 194  * @param flags Command flags.
 195  * @param top_level Top level of command execution, i.e. command from a command.
 196  * @param test Test run of command?
 197  */
 198 void CommandHelperBase::InternalDoAfter(CommandCost &res, DoCommandFlag flags, bool top_level, bool test)
 199 {
 200         if (test) {
 201                 SetTownRatingTestMode(false);
 202
 203                 if (res.Succeeded() && top_level && !(flags & DC_QUERY_COST) && !(flags & DC_BANKRUPT)) {
 204                         CheckCompanyHasMoney(res); // CheckCompanyHasMoney() modifies 'res' to an error if it fails.
 205                 }
 206         } else {
 207                 /* If top-level, subtract the money. */
 208                 if (res.Succeeded() && top_level && !(flags & DC_BANKRUPT)) {
 209                         SubtractMoneyFromCompany(res);
 210                 }
 211         }
 212 }
 213
 214 /**
 215  * Decide what to do with the command depending on current game state.
 216  * @param cmd Command to execute.
 217  * @param flags Command flags.
 218  * @param tile Tile of command execution.
 219  * @param err_message Message prefix to show on error.
 220  * @param network_command Does this command come from the network?
 221  * @return error state + do only cost estimation? + send to network only?
 222  */
 223 std::tuple<bool, bool, bool> CommandHelperBase::InternalPostBefore(Commands cmd, CommandFlags flags, TileIndex tile, StringID err_message, bool network_command)
 224 {
 225         /* Cost estimation is generally only done when the
 226          * local user presses shift while doing something.
 227          * However, in case of incoming network commands,
 228          * map generation or the pause button we do want
 229          * to execute. */
 230         bool estimate_only = _shift_pressed && IsLocalCompany() && !_generating_world && !network_command && !(flags & CMD_NO_EST);
 231
 232         /* We're only sending the command, so don't do
 233          * fancy things for 'success'. */
 234         bool only_sending = _networking && !network_command;
 235
 236         if (_pause_mode != PM_UNPAUSED && !IsCommandAllowedWhilePaused(cmd) && !estimate_only) {
 237                 ShowErrorMessage(err_message, STR_ERROR_NOT_ALLOWED_WHILE_PAUSED, WL_INFO, TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE);
 238                 return { true, estimate_only, only_sending };
 239         } else {
 240                 return { false, estimate_only, only_sending };
 241         }
 242 }
 243
 244 /**
 245  * Process result of executing a command, possibly displaying any error to the player.
 246  * @param res Command result.
 247  * @param tile Tile of command execution.
 248  * @param estimate_only Is this just cost estimation?
 249  * @param only_sending Was the command only sent to network?
 250  * @param err_message Message prefix to show on error.
 251  * @param my_cmd Is the command from this client?
 252  */
 253 void CommandHelperBase::InternalPostResult(const CommandCost &res, TileIndex tile, bool estimate_only, bool only_sending, StringID err_message, bool my_cmd)
 254 {
 255         int x = TileX(tile) * TILE_SIZE;
 256         int y = TileY(tile) * TILE_SIZE;
 257
 258         if (res.Failed()) {
 259                 /* Only show the error when it's for us. */
 260                 if (estimate_only || (IsLocalCompany() && err_message != 0 && my_cmd)) {
 261                         ShowErrorMessage(err_message, res.GetErrorMessage(), WL_INFO, x, y, res.GetTextRefStackGRF(), res.GetTextRefStackSize(), res.GetTextRefStack());
 262                 }
 263         } else if (estimate_only) {
 264                 ShowEstimatedCostOrIncome(res.GetCost(), x, y);
 265         } else if (!only_sending && tile != 0 && IsLocalCompany() && _game_mode != GM_EDITOR) {
 266                 /* Only show the cost animation when we did actually
 267                  * execute the command, i.e. we're not sending it to
 268                  * the server, when it has cost the local company
 269                  * something. Furthermore in the editor there is no
 270                  * concept of cost, so don't show it there either. */
 271                 ShowCostOrIncomeAnimation(x, y, GetSlopePixelZ(x, y), res.GetCost());
 272         }
 273 }
 274
 275 /** Helper to make a desync log for a command. */
 276 void CommandHelperBase::LogCommandExecution(Commands cmd, StringID err_message, TileIndex tile, const CommandDataBuffer &args, bool failed)
 277 {
 278         Debug(desync, 1, "{}: {:08x}; {:02x}; {:02x}; {:08x}; {:08x}; {:06x}; {} ({})", failed ? "cmdf" : "cmd", _date, _date_fract, (int)_current_company, cmd, err_message, tile, FormatArrayAsHex(args), GetCommandName(cmd));
 279 }
 280
 281 /**
 282  * Prepare for the test run of a command proc call.
 283  * @param cmd_flags Command flags.
 284  * @param tile Tile of command execution.
 285  * @param[in,out] cur_company Backup of current company at start of command execution.
 286  * @return True if test run can go ahead, false on error.
 287  */
 288 bool CommandHelperBase::InternalExecutePrepTest(CommandFlags cmd_flags, TileIndex tile, Backup<CompanyID> &cur_company)
 289 {
 290         /* Always execute server and spectator commands as spectator */
 291         bool exec_as_spectator = (cmd_flags & (CMD_SPECTATOR | CMD_SERVER)) != 0;
 292
 293         /* If the company isn't valid it may only do server command or start a new company!
 294          * The server will ditch any server commands a client sends to it, so effectively
 295          * this guards the server from executing functions for an invalid company. */
 296         if (_game_mode == GM_NORMAL && !exec_as_spectator && !Company::IsValidID(_current_company) && !(_current_company == OWNER_DEITY && (cmd_flags & CMD_DEITY) != 0)) {
 297                 return false;
 298         }
 299
 300         if (exec_as_spectator) cur_company.Change(COMPANY_SPECTATOR);
 301
 302         /* Enter test mode. */
 303         _cleared_object_areas.clear();
 304         SetTownRatingTestMode(true);
 305         BasePersistentStorageArray::SwitchMode(PSM_ENTER_TESTMODE);
 306         return true;
 307 }
 308
 309 /**
 310  * Validate result of test run and prepare for real execution.
 311  * @param cmd_flags Command flags.
 312  * @param[in,out] res Command result of test run, may be modified.
 313  * @param estimate_only Is this just cost estimation?
 314  * @param network_command Does this command come from the network?
 315  * @param[in,out] cur_company Backup of current company at start of command execution.
 316  * @return True if test run can go ahead, false on error.
 317  */
 318 std::tuple<bool, bool, bool> CommandHelperBase::InternalExecuteValidateTestAndPrepExec(CommandCost &res, CommandFlags cmd_flags, bool estimate_only, bool network_command, Backup<CompanyID> &cur_company)
 319 {
 320         BasePersistentStorageArray::SwitchMode(PSM_LEAVE_TESTMODE);
 321         SetTownRatingTestMode(false);
 322
 323         /* Make sure we're not messing things up here. */
 324         assert((cmd_flags & (CMD_SPECTATOR | CMD_SERVER)) != 0 ? _current_company == COMPANY_SPECTATOR : cur_company.Verify());
 325
 326         /* If the command fails, we're doing an estimate
 327          * or the player does not have enough money
 328          * (unless it's a command where the test and
 329          * execution phase might return different costs)
 330          * we bail out here. */
 331         bool test_and_exec_can_differ = (cmd_flags & CMD_NO_TEST) != 0;
 332         if (res.Failed() || estimate_only || (!test_and_exec_can_differ && !CheckCompanyHasMoney(res))) {
 333                 return { true, !_networking || _generating_world || network_command, false };
 334         }
 335
 336         bool send_net = _networking && !_generating_world && !network_command;
 337
 338         if (!send_net) {
 339                 /* Prepare for command execution. */
 340                 _cleared_object_areas.clear();
 341                 BasePersistentStorageArray::SwitchMode(PSM_ENTER_COMMAND);
 342         }
 343
 344         return { false, _debug_desync_level >= 1, send_net };
 345 }
 346
 347 /**
 348  * Process the result of a command test run and execution run.
 349  * @param cmd Command that was executed.
 350  * @param cmd_flags Command flags.
 351  * @param res_test Command result of test run.
 352  * @param tes_exec Command result of real run.
 353  * @param extra_cash Additional cash required for successful command execution.
 354  * @param tile Tile of command execution.
 355  * @param[in,out] cur_company Backup of current company at start of command execution.
 356  * @return Final command result.
 357  */
 358 CommandCost CommandHelperBase::InternalExecuteProcessResult(Commands cmd, CommandFlags cmd_flags, const CommandCost &res_test, const CommandCost &res_exec, Money extra_cash, TileIndex tile, Backup<CompanyID> &cur_company)
 359 {
 360         BasePersistentStorageArray::SwitchMode(PSM_LEAVE_COMMAND);
 361
 362         if (cmd == CMD_COMPANY_CTRL) {
 363                 cur_company.Trash();
 364                 /* We are a new company                  -> Switch to new local company.
 365                  * We were closed down                   -> Switch to spectator
 366                  * Some other company opened/closed down -> The outside function will switch back */
 367                 _current_company = _local_company;
 368         } else {
 369                 /* Make sure nothing bad happened, like changing the current company. */
 370                 assert((cmd_flags & (CMD_SPECTATOR | CMD_SERVER)) != 0 ? _current_company == COMPANY_SPECTATOR : cur_company.Verify());
 371                 cur_company.Restore();
 372         }
 373
 374         /* If the test and execution can differ we have to check the
 375          * return of the command. Otherwise we can check whether the
 376          * test and execution have yielded the same result,
 377          * i.e. cost and error state are the same. */
 378         bool test_and_exec_can_differ = (cmd_flags & CMD_NO_TEST) != 0;
 379         if (!test_and_exec_can_differ) {
 380                 assert(res_test.GetCost() == res_exec.GetCost() && res_test.Failed() == res_exec.Failed()); // sanity check
 381         } else if (res_exec.Failed()) {
 382                 return res_exec;
 383         }
 384
 385         /* If we're needing more money and we haven't done
 386          * anything yet, ask for the money! */
 387         if (extra_cash != 0 && res_exec.GetCost() == 0) {
 388                 /* It could happen we removed rail, thus gained money, and deleted something else.
 389                  * So make sure the signal buffer is empty even in this case */
 390                 UpdateSignalsInBuffer();
 391                 SetDParam(0, extra_cash);
 392                 return CommandCost(STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY);
 393         }
 394
 395         /* update last build coordinate of company. */
 396         if (tile != 0) {
 397                 Company *c = Company::GetIfValid(_current_company);
 398                 if (c != nullptr) c->last_build_coordinate = tile;
 399         }
 400
 401         SubtractMoneyFromCompany(res_exec);
 402
 403         /* update signals if needed */
 404         UpdateSignalsInBuffer();
 405
 406         return res_exec;
 407 }
 408
 409
 410 /**
 411  * Adds the cost of the given command return value to this cost.
 412  * Also takes a possible error message when it is set.
 413  * @param ret The command to add the cost of.
 414  */
 415 void CommandCost::AddCost(const CommandCost &ret)
 416 {
 417         this->AddCost(ret.cost);
 418         if (this->success && !ret.success) {
 419                 this->message = ret.message;
 420                 this->success = false;
 421         }
 422 }
 423
 424 /**
 425  * Values to put on the #TextRefStack for the error message.
 426  * There is only one static instance of the array, just like there is only one
 427  * instance of normal DParams.
 428  */
 429 uint32 CommandCost::textref_stack[16];
 430
 431 /**
 432  * Activate usage of the NewGRF #TextRefStack for the error message.
 433  * @param grffile NewGRF that provides the #TextRefStack
 434  * @param num_registers number of entries to copy from the temporary NewGRF registers
 435  */
 436 void CommandCost::UseTextRefStack(const GRFFile *grffile, uint num_registers)
 437 {
 438         extern TemporaryStorageArray<int32, 0x110> _temp_store;
 439
 440         assert(num_registers < lengthof(textref_stack));
 441         this->textref_stack_grffile = grffile;
 442         this->textref_stack_size = num_registers;
 443         for (uint i = 0; i < num_registers; i++) {
 444                 textref_stack[i] = _temp_store.GetValue(0x100 + i);
 445         }
 446 }