# command.cpp

Go to the documentation of this file.

    00001 /* $Id$ */
    00002
    00003 /*
    00004  * This file is part of OpenTTD.
    00005  * 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.
    00006  * 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.
    00007  * 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/>.
    00008  */
    00009
    00012 #include "stdafx.h"
    00013 #include "landscape.h"
    00014 #include "gui.h"
    00015 #include "command_func.h"
    00016 #include "network/network_type.h"
    00017 #include "network/network.h"
    00018 #include "genworld.h"
    00019 #include "newgrf_storage.h"
    00020 #include "strings_func.h"
    00021 #include "gfx_func.h"
    00022 #include "texteff.hpp"
    00023 #include "town.h"
    00024 #include "date_func.h"
    00025 #include "company_func.h"
    00026 #include "company_base.h"
    00027 #include "signal_func.h"
    00028 #include "core/backup_type.hpp"
    00029 #include "object_base.h"
    00030 #include "window_func.h"
    00031 #include "watch_gui.h"
    00032
    00033 #include "table/strings.h"
    00034
    00035 CommandProc CmdBuildRailroadTrack;
    00036 CommandProc CmdRemoveRailroadTrack;
    00037 CommandProc CmdBuildSingleRail;
    00038 CommandProc CmdRemoveSingleRail;
    00039
    00040 CommandProc CmdLandscapeClear;
    00041
    00042 CommandProc CmdBuildBridge;
    00043
    00044 CommandProc CmdBuildRailStation;
    00045 CommandProc CmdRemoveFromRailStation;
    00046 CommandProc CmdConvertRail;
    00047
    00048 CommandProc CmdBuildSingleSignal;
    00049 CommandProc CmdRemoveSingleSignal;
    00050
    00051 CommandProc CmdTerraformLand;
    00052
    00053 CommandProc CmdBuildObject;
    00054 CommandProc CmdSellLandArea;
    00055
    00056 CommandProc CmdBuildTunnel;
    00057
    00058 CommandProc CmdBuildTrainDepot;
    00059 CommandProc CmdBuildRailWaypoint;
    00060 CommandProc CmdRenameWaypoint;
    00061 CommandProc CmdRemoveFromRailWaypoint;
    00062
    00063 CommandProc CmdBuildRoadStop;
    00064 CommandProc CmdRemoveRoadStop;
    00065
    00066 CommandProc CmdBuildLongRoad;
    00067 CommandProc CmdRemoveLongRoad;
    00068 CommandProc CmdBuildRoad;
    00069
    00070 CommandProc CmdBuildRoadDepot;
    00071
    00072 CommandProc CmdBuildAirport;
    00073
    00074 CommandProc CmdBuildDock;
    00075
    00076 CommandProc CmdBuildShipDepot;
    00077
    00078 CommandProc CmdBuildBuoy;
    00079
    00080 CommandProc CmdPlantTree;
    00081
    00082 CommandProc CmdMoveRailVehicle;
    00083
    00084 CommandProc CmdBuildVehicle;
    00085 CommandProc CmdSellVehicle;
    00086 CommandProc CmdRefitVehicle;
    00087 CommandProc CmdSendVehicleToDepot;
    00088
    00089 CommandProc CmdForceTrainProceed;
    00090 CommandProc CmdReverseTrainDirection;
    00091
    00092 CommandProc CmdClearOrderBackup;
    00093 CommandProc CmdModifyOrder;
    00094 CommandProc CmdSkipToOrder;
    00095 CommandProc CmdDeleteOrder;
    00096 CommandProc CmdInsertOrder;
    00097 CommandProc CmdChangeServiceInt;
    00098
    00099 CommandProc CmdBuildIndustry;
    00100
    00101 CommandProc CmdSetCompanyManagerFace;
    00102 CommandProc CmdSetCompanyColour;
    00103
    00104 CommandProc CmdIncreaseLoan;
    00105 CommandProc CmdDecreaseLoan;
    00106
    00107 CommandProc CmdWantEnginePreview;
    00108
    00109 CommandProc CmdRenameVehicle;
    00110 CommandProc CmdRenameEngine;
    00111
    00112 CommandProc CmdRenameCompany;
    00113 CommandProc CmdRenamePresident;
    00114
    00115 CommandProc CmdRenameStation;
    00116 CommandProc CmdRenameDepot;
    00117
    00118 CommandProc CmdPlaceSign;
    00119 CommandProc CmdRenameSign;
    00120
    00121 CommandProc CmdTurnRoadVeh;
    00122
    00123 CommandProc CmdPause;
    00124
    00125 CommandProc CmdBuyShareInCompany;
    00126 CommandProc CmdSellShareInCompany;
    00127 CommandProc CmdBuyCompany;
    00128
    00129 CommandProc CmdFoundTown;
    00130 CommandProc CmdRenameTown;
    00131 CommandProc CmdDoTownAction;
    00132 CommandProc CmdExpandTown;
    00133 CommandProc CmdDeleteTown;
    00134
    00135 CommandProc CmdChangeSetting;
    00136 CommandProc CmdChangeCompanySetting;
    00137
    00138 CommandProc CmdOrderRefit;
    00139 CommandProc CmdCloneOrder;
    00140
    00141 CommandProc CmdClearArea;
    00142
    00143 CommandProc CmdGiveMoney;
    00144 CommandProc CmdMoneyCheat;
    00145 CommandProc CmdBuildCanal;
    00146 CommandProc CmdBuildLock;
    00147
    00148 CommandProc CmdCompanyCtrl;
    00149
    00150 CommandProc CmdLevelLand;
    00151
    00152 CommandProc CmdBuildSignalTrack;
    00153 CommandProc CmdRemoveSignalTrack;
    00154
    00155 CommandProc CmdSetAutoReplace;
    00156
    00157 CommandProc CmdCloneVehicle;
    00158 CommandProc CmdStartStopVehicle;
    00159 CommandProc CmdMassStartStopVehicle;
    00160 CommandProc CmdAutoreplaceVehicle;
    00161 CommandProc CmdDepotSellAllVehicles;
    00162 CommandProc CmdDepotMassAutoReplace;
    00163
    00164 CommandProc CmdCreateGroup;
    00165 CommandProc CmdRenameGroup;
    00166 CommandProc CmdDeleteGroup;
    00167 CommandProc CmdAddVehicleGroup;
    00168 CommandProc CmdAddSharedVehicleGroup;
    00169 CommandProc CmdRemoveAllVehiclesGroup;
    00170 CommandProc CmdSetGroupReplaceProtection;
    00171
    00172 CommandProc CmdMoveOrder;
    00173 CommandProc CmdChangeTimetable;
    00174 CommandProc CmdSetVehicleOnTime;
    00175 CommandProc CmdAutofillTimetable;
    00176 CommandProc CmdAutomateTimetable;
    00177 CommandProc CmdSetTimetableStart;
    00178
    00179 CommandProc CmdInsertSignalInstruction;
    00180 CommandProc CmdModifySignalInstruction;
    00181 CommandProc CmdRemoveSignalInstruction;
    00182
    00183 CommandProc CmdSetSignalSpeedLimit;
    00184
    00185 CommandProc CmdBuildTrafficLights;
    00186 CommandProc CmdRemoveTrafficLights;
    00187
    00188 #define DEF_CMD(proc, flags, type) {proc, #proc, flags, type}
    00189
    00197 static const Command _command_proc_table[] = {
    00198   DEF_CMD(CmdBuildRailroadTrack,       CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_RAILROAD_TRACK
    00199   DEF_CMD(CmdRemoveRailroadTrack,                     CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_RAILROAD_TRACK
    00200   DEF_CMD(CmdBuildSingleRail,          CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_SINGLE_RAIL
    00201   DEF_CMD(CmdRemoveSingleRail,                        CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_SINGLE_RAIL
    00202   DEF_CMD(CmdLandscapeClear,                                 0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_LANDSCAPE_CLEAR
    00203   DEF_CMD(CmdBuildBridge,              CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_BRIDGE
    00204   DEF_CMD(CmdBuildRailStation,         CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_RAIL_STATION
    00205   DEF_CMD(CmdBuildTrainDepot,          CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_TRAIN_DEPOT
    00206   DEF_CMD(CmdBuildSingleSignal,                       CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_SIGNALS
    00207   DEF_CMD(CmdRemoveSingleSignal,                      CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_SIGNALS
    00208   DEF_CMD(CmdTerraformLand,           CMD_ALL_TILES | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_TERRAFORM_LAND
    00209   DEF_CMD(CmdBuildObject,              CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_OBJECT
    00210   DEF_CMD(CmdBuildTunnel,                             CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_TUNNEL
    00211   DEF_CMD(CmdRemoveFromRailStation,                          0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_FROM_RAIL_STATION
    00212   DEF_CMD(CmdConvertRail,                                    0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_CONVERT_RAILD
    00213   DEF_CMD(CmdBuildRailWaypoint,                              0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_RAIL_WAYPOINT
    00214   DEF_CMD(CmdRenameWaypoint,                                 0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_WAYPOINT
    00215   DEF_CMD(CmdRemoveFromRailWaypoint,                         0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_FROM_RAIL_WAYPOINT
    00216
    00217   DEF_CMD(CmdBuildRoadStop,            CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_ROAD_STOP
    00218   DEF_CMD(CmdRemoveRoadStop,                                 0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_ROAD_STOP
    00219   DEF_CMD(CmdBuildLongRoad,            CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_LONG_ROAD
    00220   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.
    00221   DEF_CMD(CmdBuildRoad,                CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_ROAD
    00222   DEF_CMD(CmdBuildRoadDepot,           CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_ROAD_DEPOT
    00223
    00224   DEF_CMD(CmdBuildAirport,             CMD_NO_WATER | CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_AIRPORT
    00225   DEF_CMD(CmdBuildDock,                               CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_DOCK
    00226   DEF_CMD(CmdBuildShipDepot,                          CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_SHIP_DEPOT
    00227   DEF_CMD(CmdBuildBuoy,                               CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_BUOY
    00228   DEF_CMD(CmdPlantTree,                               CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_PLANT_TREE
    00229
    00230   DEF_CMD(CmdBuildVehicle,                       CMD_CLIENT_ID, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_BUILD_VEHICLE
    00231   DEF_CMD(CmdSellVehicle,                        CMD_CLIENT_ID, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_SELL_VEHICLE
    00232   DEF_CMD(CmdRefitVehicle,                                   0, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_REFIT_VEHICLE
    00233   DEF_CMD(CmdSendVehicleToDepot,                             0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_SEND_VEHICLE_TO_DEPOT
    00234
    00235   DEF_CMD(CmdMoveRailVehicle,                                0, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_MOVE_RAIL_VEHICLE
    00236   DEF_CMD(CmdForceTrainProceed,                              0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_FORCE_TRAIN_PROCEED
    00237   DEF_CMD(CmdReverseTrainDirection,                          0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_REVERSE_TRAIN_DIRECTION
    00238
    00239   DEF_CMD(CmdClearOrderBackup,                   CMD_CLIENT_ID, CMDT_ROUTE_MANAGEMENT      ), // CMD_CLEAR_ORDER_BACKUP
    00240   DEF_CMD(CmdModifyOrder,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_MODIFY_ORDER
    00241   DEF_CMD(CmdSkipToOrder,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_SKIP_TO_ORDER
    00242   DEF_CMD(CmdDeleteOrder,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_DELETE_ORDER
    00243   DEF_CMD(CmdInsertOrder,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_INSERT_ORDER
    00244
    00245   DEF_CMD(CmdChangeServiceInt,                               0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_CHANGE_SERVICE_INT
    00246
    00247   DEF_CMD(CmdBuildIndustry,                                  0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_INDUSTRY
    00248   DEF_CMD(CmdSetCompanyManagerFace,                          0, CMDT_OTHER_MANAGEMENT      ), // CMD_SET_COMPANY_MANAGER_FACE
    00249   DEF_CMD(CmdSetCompanyColour,                               0, CMDT_OTHER_MANAGEMENT      ), // CMD_SET_COMPANY_COLOUR
    00250
    00251   DEF_CMD(CmdIncreaseLoan,                                   0, CMDT_MONEY_MANAGEMENT      ), // CMD_INCREASE_LOAN
    00252   DEF_CMD(CmdDecreaseLoan,                                   0, CMDT_MONEY_MANAGEMENT      ), // CMD_DECREASE_LOAN
    00253
    00254   DEF_CMD(CmdWantEnginePreview,                              0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_WANT_ENGINE_PREVIEW
    00255
    00256   DEF_CMD(CmdRenameVehicle,                                  0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_VEHICLE
    00257   DEF_CMD(CmdRenameEngine,                                   0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_ENGINE
    00258
    00259   DEF_CMD(CmdRenameCompany,                                  0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_COMPANY
    00260   DEF_CMD(CmdRenamePresident,                                0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_PRESIDENT
    00261
    00262   DEF_CMD(CmdRenameStation,                                  0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_STATION
    00263   DEF_CMD(CmdRenameDepot,                                    0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_DEPOT
    00264
    00265   DEF_CMD(CmdPlaceSign,                                      0, CMDT_OTHER_MANAGEMENT      ), // CMD_PLACE_SIGN
    00266   DEF_CMD(CmdRenameSign,                                     0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_SIGN
    00267
    00268   DEF_CMD(CmdTurnRoadVeh,                                    0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_TURN_ROADVEH
    00269
    00270   DEF_CMD(CmdPause,                                 CMD_SERVER, CMDT_SERVER_SETTING        ), // CMD_PAUSE
    00271
    00272   DEF_CMD(CmdBuyShareInCompany,                              0, CMDT_MONEY_MANAGEMENT      ), // CMD_BUY_SHARE_IN_COMPANY
    00273   DEF_CMD(CmdSellShareInCompany,                             0, CMDT_MONEY_MANAGEMENT      ), // CMD_SELL_SHARE_IN_COMPANY
    00274   DEF_CMD(CmdBuyCompany,                                     0, CMDT_MONEY_MANAGEMENT      ), // CMD_BUY_COMANY
    00275
    00276   DEF_CMD(CmdFoundTown,                            CMD_NO_TEST, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_FOUND_TOWN; founding random town can fail only in exec run
    00277   DEF_CMD(CmdRenameTown,                            CMD_SERVER, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_TOWN
    00278   DEF_CMD(CmdDoTownAction,                                   0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_DO_TOWN_ACTION
    00279   DEF_CMD(CmdExpandTown,                           CMD_OFFLINE, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_EXPAND_TOWN
    00280   DEF_CMD(CmdDeleteTown,                           CMD_OFFLINE, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_DELETE_TOWN
    00281
    00282   DEF_CMD(CmdOrderRefit,                                     0, CMDT_ROUTE_MANAGEMENT      ), // CMD_ORDER_REFIT
    00283   DEF_CMD(CmdCloneOrder,                                     0, CMDT_ROUTE_MANAGEMENT      ), // CMD_CLONE_ORDER
    00284
    00285   DEF_CMD(CmdClearArea,                            CMD_NO_TEST, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_CLEAR_AREA; destroying multi-tile houses makes town rating differ between test and execution
    00286
    00287   DEF_CMD(CmdMoneyCheat,                           CMD_OFFLINE, CMDT_CHEAT                 ), // CMD_MONEY_CHEAT
    00288   DEF_CMD(CmdBuildCanal,                              CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_CANAL
    00289   DEF_CMD(CmdCompanyCtrl,        CMD_SPECTATOR | CMD_CLIENT_ID, CMDT_SERVER_SETTING        ), // CMD_COMPANY_CTRL
    00290
    00291   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
    00292
    00293   DEF_CMD(CmdBuildLock,                               CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_LOCK
    00294
    00295   DEF_CMD(CmdBuildSignalTrack,                        CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_SIGNAL_TRACK
    00296   DEF_CMD(CmdRemoveSignalTrack,                       CMD_AUTO, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_SIGNAL_TRACK
    00297
    00298   DEF_CMD(CmdGiveMoney,                                      0, CMDT_MONEY_MANAGEMENT      ), // CMD_GIVE_MONEY
    00299   DEF_CMD(CmdChangeSetting,                         CMD_SERVER, CMDT_SERVER_SETTING        ), // CMD_CHANGE_SETTING
    00300   DEF_CMD(CmdChangeCompanySetting,                           0, CMDT_COMPANY_SETTING       ), // CMD_CHANGE_COMPANY_SETTING
    00301   DEF_CMD(CmdSetAutoReplace,                                 0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_SET_AUTOREPLACE
    00302   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
    00303   DEF_CMD(CmdStartStopVehicle,                               0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_START_STOP_VEHICLE
    00304   DEF_CMD(CmdMassStartStopVehicle,                           0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_MASS_START_STOP
    00305   DEF_CMD(CmdAutoreplaceVehicle,                             0, CMDT_VEHICLE_MANAGEMENT    ), // CMD_AUTOREPLACE_VEHICLE
    00306   DEF_CMD(CmdDepotSellAllVehicles,                           0, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_DEPOT_SELL_ALL_VEHICLES
    00307   DEF_CMD(CmdDepotMassAutoReplace,                           0, CMDT_VEHICLE_CONSTRUCTION  ), // CMD_DEPOT_MASS_AUTOREPLACE
    00308   DEF_CMD(CmdCreateGroup,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_CREATE_GROUP
    00309   DEF_CMD(CmdDeleteGroup,                                    0, CMDT_ROUTE_MANAGEMENT      ), // CMD_DELETE_GROUP
    00310   DEF_CMD(CmdRenameGroup,                                    0, CMDT_OTHER_MANAGEMENT      ), // CMD_RENAME_GROUP
    00311   DEF_CMD(CmdAddVehicleGroup,                                0, CMDT_ROUTE_MANAGEMENT      ), // CMD_ADD_VEHICLE_GROUP
    00312   DEF_CMD(CmdAddSharedVehicleGroup,                          0, CMDT_ROUTE_MANAGEMENT      ), // CMD_ADD_SHARE_VEHICLE_GROUP
    00313   DEF_CMD(CmdRemoveAllVehiclesGroup,                         0, CMDT_ROUTE_MANAGEMENT      ), // CMD_REMOVE_ALL_VEHICLES_GROUP
    00314   DEF_CMD(CmdSetGroupReplaceProtection,                      0, CMDT_ROUTE_MANAGEMENT      ), // CMD_SET_GROUP_REPLACE_PROTECTION
    00315   DEF_CMD(CmdMoveOrder,                                      0, CMDT_ROUTE_MANAGEMENT      ), // CMD_MOVE_ORDER
    00316   DEF_CMD(CmdChangeTimetable,                                0, CMDT_ROUTE_MANAGEMENT      ), // CMD_CHANGE_TIMETABLE
    00317   DEF_CMD(CmdSetVehicleOnTime,                               0, CMDT_ROUTE_MANAGEMENT      ), // CMD_SET_VEHICLE_ON_TIME
    00318   DEF_CMD(CmdAutofillTimetable,                              0, CMDT_ROUTE_MANAGEMENT      ), // CMD_AUTOFILL_TIMETABLE
    00319   DEF_CMD(CmdAutomateTimetable,                              0, CMDT_ROUTE_MANAGEMENT      ), // CMD_AUTOMATE_TIMETABLE
    00320   DEF_CMD(CmdSetTimetableStart,                              0, CMDT_ROUTE_MANAGEMENT      ), // CMD_SET_TIMETABLE_START
    00321   DEF_CMD(CmdInsertSignalInstruction,                        0, CMDT_OTHER_MANAGEMENT      ), // CMD_INSERT_SIGNAL_INSTRUCTION
    00322   DEF_CMD(CmdModifySignalInstruction,                        0, CMDT_OTHER_MANAGEMENT      ), // CMD_MODIFY_SIGNAL_INSTRUCTION
    00323   DEF_CMD(CmdRemoveSignalInstruction,                        0, CMDT_OTHER_MANAGEMENT      ), // CMD_REMOVE_SIGNAL_INSTRUCTION
    00324   DEF_CMD(CmdSetSignalSpeedLimit,                            0, CMDT_OTHER_MANAGEMENT      ), // CMD_SET_SIGNAL_SPEED_LIMIT
    00325   DEF_CMD(CmdBuildTrafficLights,                             0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_BUILD_TRAFFICLIGHTS
    00326   DEF_CMD(CmdRemoveTrafficLights,                  0, CMDT_LANDSCAPE_CONSTRUCTION), // CMD_REMOVE_TRAFFICLIGHTS
    00327 };
    00328
    00335 bool IsValidCommand(uint32 cmd)
    00336 {
    00337   cmd &= CMD_ID_MASK;
    00338
    00339   return cmd < lengthof(_command_proc_table) && _command_proc_table[cmd].proc != NULL;
    00340 }
    00341
    00349 byte GetCommandFlags(uint32 cmd)
    00350 {
    00351   assert(IsValidCommand(cmd));
    00352
    00353   return _command_proc_table[cmd & CMD_ID_MASK].flags;
    00354 }
    00355
    00363 const char *GetCommandName(uint32 cmd)
    00364 {
    00365   assert(IsValidCommand(cmd));
    00366
    00367   return _command_proc_table[cmd & CMD_ID_MASK].name;
    00368 }
    00369
    00375 bool IsCommandAllowedWhilePaused(uint32 cmd)
    00376 {
    00377   /* Lookup table for the command types that are allowed for a given pause level setting. */
    00378   static const int command_type_lookup[] = {
    00379     CMDPL_ALL_ACTIONS,
    00380     CMDPL_NO_LANDSCAPING,
    00381     CMDPL_NO_LANDSCAPING,
    00382     CMDPL_NO_CONSTRUCTION,
    00383     CMDPL_NO_CONSTRUCTION,
    00384     CMDPL_NO_CONSTRUCTION,
    00385     CMDPL_NO_CONSTRUCTION,
    00386     CMDPL_NO_ACTIONS,
    00387     CMDPL_NO_ACTIONS,
    00388   };
    00389   assert_compile(lengthof(command_type_lookup) == CMDT_END);
    00390
    00391   assert(IsValidCommand(cmd));
    00392   return _game_mode == GM_EDITOR || command_type_lookup[_command_proc_table[cmd & CMD_ID_MASK].type] <= _settings_game.construction.command_pause_level;
    00393 }
    00394
    00395
    00396 static int _docommand_recursive = 0;
    00397
    00406 CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
    00407 {
    00408   return DoCommand(container->tile, container->p1, container->p2, flags, container->cmd & CMD_ID_MASK, container->text);
    00409 }
    00410
    00424 CommandCost DoCommand(TileIndex tile, uint32 p1, uint32 p2, DoCommandFlag flags, uint32 cmd, const char *text)
    00425 {
    00426   CommandCost res;
    00427
    00428   /* Do not even think about executing out-of-bounds tile-commands */
    00429   if (tile != 0 && (tile >= MapSize() || (!IsValidTile(tile) && (flags & DC_ALL_TILES) == 0))) return CMD_ERROR;
    00430
    00431   /* Chop of any CMD_MSG or other flags; we don't need those here */
    00432   CommandProc *proc = _command_proc_table[cmd & CMD_ID_MASK].proc;
    00433
    00434   _docommand_recursive++;
    00435
    00436   /* only execute the test call if it's toplevel, or we're not execing. */
    00437   if (_docommand_recursive == 1 || !(flags & DC_EXEC) ) {
    00438     if (_docommand_recursive == 1) _cleared_object_areas.Clear();
    00439     SetTownRatingTestMode(true);
    00440     res = proc(tile, flags & ~DC_EXEC, p1, p2, text);
    00441     SetTownRatingTestMode(false);
    00442     if (res.Failed()) {
    00443       goto error;
    00444     }
    00445
    00446     if (_docommand_recursive == 1 &&
    00447         !(flags & DC_QUERY_COST) &&
    00448         !(flags & DC_BANKRUPT) &&
    00449         !CheckCompanyHasMoney(res)) { // CheckCompanyHasMoney() modifies 'res' to an error if it fails.
    00450       goto error;
    00451     }
    00452
    00453     if (!(flags & DC_EXEC)) {
    00454       _docommand_recursive--;
    00455       return res;
    00456     }
    00457   }
    00458
    00459   /* Execute the command here. All cost-relevant functions set the expenses type
    00460    * themselves to the cost object at some point */
    00461   if (_docommand_recursive == 1) _cleared_object_areas.Clear();
    00462   res = proc(tile, flags, p1, p2, text);
    00463   if (res.Failed()) {
    00464 error:
    00465     _docommand_recursive--;
    00466     return res;
    00467   }
    00468
    00469   /* if toplevel, subtract the money. */
    00470   if (--_docommand_recursive == 0 && !(flags & DC_BANKRUPT)) {
    00471     SubtractMoneyFromCompany(res);
    00472   }
    00473
    00474   return res;
    00475 }
    00476
    00484 Money GetAvailableMoneyForCommand()
    00485 {
    00486   CompanyID company = _current_company;
    00487   if (!Company::IsValidID(company)) return INT64_MAX;
    00488   return Company::Get(company)->money;
    00489 }
    00490
    00497 bool DoCommandP(const CommandContainer *container, bool my_cmd)
    00498 {
    00499   return DoCommandP(container->tile, container->p1, container->p2, container->cmd, container->callback, container->text, my_cmd);
    00500 }
    00501
    00517 bool DoCommandP(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const char *text, bool my_cmd)
    00518 {
    00519   /* Cost estimation is generally only done when the
    00520    * local user presses shift while doing somthing.
    00521    * However, in case of incoming network commands,
    00522    * map generation of the pause button we do want
    00523    * to execute. */
    00524   bool estimate_only = _shift_pressed && IsLocalCompany() &&
    00525       !IsGeneratingWorld() &&
    00526       !(cmd & CMD_NETWORK_COMMAND) &&
    00527       (cmd & CMD_ID_MASK) != CMD_PAUSE;
    00528
    00529   /* We're only sending the command, so don't do
    00530    * fancy things for 'success'. */
    00531   bool only_sending = _networking && !(cmd & CMD_NETWORK_COMMAND);
    00532
    00533   /* Where to show the message? */
    00534   int x = TileX(tile) * TILE_SIZE;
    00535   int y = TileY(tile) * TILE_SIZE;
    00536
    00537   if (_pause_mode != PM_UNPAUSED && !IsCommandAllowedWhilePaused(cmd)) {
    00538     ShowErrorMessage(GB(cmd, 16, 16), STR_ERROR_NOT_ALLOWED_WHILE_PAUSED, WL_INFO, x, y);
    00539     return false;
    00540   }
    00541
    00542 #ifdef ENABLE_NETWORK
    00543   /* Only set p2 when the command does not come from the network. */
    00544   if (!(cmd & CMD_NETWORK_COMMAND) && GetCommandFlags(cmd) & CMD_CLIENT_ID && p2 == 0) p2 = CLIENT_ID_SERVER;
    00545 #endif
    00546
    00547   CommandCost res = DoCommandPInternal(tile, p1, p2, cmd, callback, text, my_cmd, estimate_only);
    00548   if (res.Failed()) {
    00549     /* Only show the error when it's for us. */
    00550     StringID error_part1 = GB(cmd, 16, 16);
    00551     if (estimate_only || (IsLocalCompany() && error_part1 != 0 && my_cmd)) {
    00552       ShowErrorMessage(error_part1, res.GetErrorMessage(), WL_INFO, x, y);
    00553     }
    00554   } else if (estimate_only) {
    00555     ShowEstimatedCostOrIncome(res.GetCost(), x, y);
    00556   } else if (!only_sending && res.GetCost() != 0 && tile != 0 && IsLocalCompany() && _game_mode != GM_EDITOR) {
    00557     /* Only show the cost animation when we did actually
    00558      * execute the command, i.e. we're not sending it to
    00559      * the server, when it has cost the local company
    00560      * something. Furthermore in the editor there is no
    00561      * concept of cost, so don't show it there either. */
    00562     ShowCostOrIncomeAnimation(x, y, GetSlopeZ(x, y), res.GetCost());
    00563   }
    00564
    00565   if (!estimate_only && !only_sending && callback != NULL) {
    00566     callback(res, tile, p1, p2);
    00567   }
    00568
    00569   return res.Succeeded();
    00570 }
    00571
    00572
    00578 #define return_dcpi(cmd, clear) { _docommand_recursive = 0; ClearStorageChanges(clear); return cmd; }
    00579
    00593 CommandCost DoCommandPInternal(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const char *text, bool my_cmd, bool estimate_only)
    00594 {
    00595   /* Prevent recursion; it gives a mess over the network */
    00596   assert(_docommand_recursive == 0);
    00597   _docommand_recursive = 1;
    00598
    00599   /* Reset the state. */
    00600   _additional_cash_required = 0;
    00601
    00602   /* Get pointer to command handler */
    00603   byte cmd_id = cmd & CMD_ID_MASK;
    00604   assert(cmd_id < lengthof(_command_proc_table));
    00605
    00606   CommandProc *proc = _command_proc_table[cmd_id].proc;
    00607   /* Shouldn't happen, but you never know when someone adds
    00608    * NULLs to the _command_proc_table. */
    00609   assert(proc != NULL);
    00610
    00611   /* Command flags are used internally */
    00612   uint cmd_flags = GetCommandFlags(cmd);
    00613   /* Flags get send to the DoCommand */
    00614   DoCommandFlag flags = CommandFlagsToDCFlags(cmd_flags);
    00615
    00616 #ifdef ENABLE_NETWORK
    00617   /* Make sure p2 is properly set to a ClientID. */
    00618   assert(!(cmd_flags & CMD_CLIENT_ID) || p2 != 0);
    00619 #endif
    00620
    00621   /* Do not even think about executing out-of-bounds tile-commands */
    00622   if (tile != 0 && (tile >= MapSize() || (!IsValidTile(tile) && (cmd_flags & CMD_ALL_TILES) == 0))) return_dcpi(CMD_ERROR, false);
    00623
    00624   /* Always execute server and spectator commands as spectator */
    00625   bool exec_as_spectator = (cmd_flags & (CMD_SPECTATOR | CMD_SERVER)) != 0;
    00626
    00627   /* If the company isn't valid it may only do server command or start a new company!
    00628    * The server will ditch any server commands a client sends to it, so effectively
    00629    * this guards the server from executing functions for an invalid company. */
    00630   if (_game_mode == GM_NORMAL && !exec_as_spectator && !Company::IsValidID(_current_company)) {
    00631     return_dcpi(CMD_ERROR, false);
    00632   }
    00633
    00634   Backup<CompanyByte> cur_company(_current_company, FILE_LINE);
    00635   if (exec_as_spectator) cur_company.Change(COMPANY_SPECTATOR);
    00636
    00637   bool test_and_exec_can_differ = (cmd_flags & CMD_NO_TEST) != 0;
    00638   bool skip_test = _networking && (cmd & CMD_NO_TEST_IF_IN_NETWORK) != 0;
    00639
    00640   /* Do we need to do a test run?
    00641    * Basically we need to always do this, except when
    00642    * the no-test-in-network flag is giving and we're
    00643    * in a network game (e.g. restoring orders would
    00644    * fail this test because the first order does not
    00645    * exist yet when inserting the second, giving that
    00646    * a wrong insert location and ignoring the command
    00647    * and thus breaking restoring). However, when we
    00648    * just want to do cost estimation we don't care
    00649    * because it's only done once anyway. */
    00650   CommandCost res;
    00651   if (estimate_only || !skip_test) {
    00652     /* Test the command. */
    00653     _cleared_object_areas.Clear();
    00654     SetTownRatingTestMode(true);
    00655     res = proc(tile, flags, p1, p2, text);
    00656     SetTownRatingTestMode(false);
    00657
    00658     /* Make sure we're not messing things up here. */
    00659     assert(exec_as_spectator ? _current_company == COMPANY_SPECTATOR : cur_company.Verify());
    00660
    00661     /* If the command fails, we're doing an estimate
    00662      * or the player does not have enough money
    00663      * (unless it's a command where the test and
    00664      * execution phase might return different costs)
    00665      * we bail out here. */
    00666     if (res.Failed() || estimate_only ||
    00667         (!test_and_exec_can_differ && !CheckCompanyHasMoney(res))) {
    00668       cur_company.Restore();
    00669       return_dcpi(res, false);
    00670     }
    00671   }
    00672
    00673 #ifdef ENABLE_NETWORK
    00674   /*
    00675    * If we are in network, and the command is not from the network
    00676    * send it to the command-queue and abort execution
    00677    */
    00678   if (_networking && !(cmd & CMD_NETWORK_COMMAND)) {
    00679     NetworkSendCommand(tile, p1, p2, cmd & ~CMD_FLAGS_MASK, callback, text, _current_company);
    00680     cur_company.Restore();
    00681
    00682     /* Don't return anything special here; no error, no costs.
    00683      * This way it's not handled by DoCommand and only the
    00684      * actual execution of the command causes messages. Also
    00685      * reset the storages as we've not executed the command. */
    00686     return_dcpi(CommandCost(), false);
    00687   }
    00688 #endif /* ENABLE_NETWORK */
    00689   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));
    00690
    00691   /* Actually try and execute the command. If no cost-type is given
    00692    * use the construction one */
    00693   _cleared_object_areas.Clear();
    00694   CommandCost res2 = proc(tile, flags | DC_EXEC, p1, p2, text);
    00695
    00696   if (cmd_id == CMD_COMPANY_CTRL) {
    00697     cur_company.Trash();
    00698     /* We are a new company                  -> Switch to new local company.
    00699      * We were closed down                   -> Switch to spectator
    00700      * Some other company opened/closed down -> The outside function will switch back */
    00701     _current_company = _local_company;
    00702   } else {
    00703     /* Make sure nothing bad happened, like changing the current company. */
    00704     assert(exec_as_spectator ? _current_company == COMPANY_SPECTATOR : cur_company.Verify());
    00705     cur_company.Restore();
    00706   }
    00707
    00708   /* If the test and execution can differ, or we skipped the test
    00709    * we have to check the return of the command. Otherwise we can
    00710    * check whether the test and execution have yielded the same
    00711    * result, i.e. cost and error state are the same. */
    00712   if (!test_and_exec_can_differ && !skip_test) {
    00713     assert(res.GetCost() == res2.GetCost() && res.Failed() == res2.Failed()); // sanity check
    00714   } else if (res2.Failed()) {
    00715     return_dcpi(res2, false);
    00716   }
    00717
    00718   /* If we're needing more money and we haven't done
    00719    * anything yet, ask for the money! */
    00720   if (_additional_cash_required != 0 && res2.GetCost() == 0) {
    00721     /* It could happen we removed rail, thus gained money, and deleted something else.
    00722      * So make sure the signal buffer is empty even in this case */
    00723     UpdateSignalsInBuffer();
    00724     SetDParam(0, _additional_cash_required);
    00725     return_dcpi(CommandCost(STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY), false);
    00726   }
    00727
    00728   /* update last build coordinate of company. */
    00729   if (tile != 0) {
    00730     Company *c = Company::GetIfValid(_current_company);
    00731     if (c != NULL) c->last_build_coordinate = tile;
    00732   }
    00733
    00734   /* Send Tile Number to Watching Company Windows */
    00735   int watching_window = 0;
    00736   WatchCompany *wc;
    00737   wc = dynamic_cast<WatchCompany*>(FindWindowById(WC_WATCH_COMPANY, watching_window));
    00738   while (wc!=NULL) {
    00739     wc->OnDoCommand( _current_company, tile );
    00740     watching_window++;
    00741     wc = dynamic_cast<WatchCompany*>(FindWindowById(WC_WATCH_COMPANY, watching_window));
    00742   }
    00743
    00744   SubtractMoneyFromCompany(res2);
    00745
    00746   /* update signals if needed */
    00747   UpdateSignalsInBuffer();
    00748
    00749   return_dcpi(res2, true);
    00750 }
    00751 #undef return_dcpi
    00752
    00753
    00759 void CommandCost::AddCost(const CommandCost &ret)
    00760 {
    00761   this->AddCost(ret.cost);
    00762   if (this->success && !ret.success) {
    00763     this->message = ret.message;
    00764     this->success = false;
    00765   }
    00766 }