1

/* $Id$ */

     2

     3

/** @file command.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/strings.h"

     8

#include "landscape.h"

     9

#include "tile_map.h"

    10

#include "gui.h"

    11

#include "command_func.h"

    12

#include "player.h"

    13

#include "network/network.h"

    14

#include "variables.h"

    15

#include "genworld.h"

    16

#include "newgrf_storage.h"

    17

#include "strings_func.h"

    18

#include "gfx_func.h"

    19

#include "functions.h"

    20

    21

const char *_cmd_text = NULL;

    22

    23

/**

    24

 * Helper macro to define the header of all command handler macros.

    25

 *

    26

 * This macro create the function header for a given command handler function, as

    27

 * all command handler functions got the parameters from the #CommandProc callback

    28

 * type.

    29

 *

    30

 * @param yyyy The desired function name of the new command handler function.

    31

 */

    32

#define DEF_COMMAND(yyyy) CommandCost yyyy(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

    33

    34

DEF_COMMAND(CmdBuildRailroadTrack);

    35

DEF_COMMAND(CmdRemoveRailroadTrack);

    36

DEF_COMMAND(CmdBuildSingleRail);

    37

DEF_COMMAND(CmdRemoveSingleRail);

    38

    39

DEF_COMMAND(CmdLandscapeClear);

    40

    41

DEF_COMMAND(CmdBuildBridge);

    42

    43

DEF_COMMAND(CmdBuildRailroadStation);

    44

DEF_COMMAND(CmdRemoveFromRailroadStation);

    45

DEF_COMMAND(CmdConvertRail);

    46

    47

DEF_COMMAND(CmdBuildSingleSignal);

    48

DEF_COMMAND(CmdRemoveSingleSignal);

    49

    50

DEF_COMMAND(CmdTerraformLand);

    51

    52

DEF_COMMAND(CmdPurchaseLandArea);

    53

DEF_COMMAND(CmdSellLandArea);

    54

    55

DEF_COMMAND(CmdBuildTunnel);

    56

    57

DEF_COMMAND(CmdBuildTrainDepot);

    58

DEF_COMMAND(CmdBuildTrainWaypoint);

    59

DEF_COMMAND(CmdRenameWaypoint);

    60

DEF_COMMAND(CmdRemoveTrainWaypoint);

    61

    62

DEF_COMMAND(CmdBuildRoadStop);

    63

DEF_COMMAND(CmdRemoveRoadStop);

    64

    65

DEF_COMMAND(CmdBuildLongRoad);

    66

DEF_COMMAND(CmdRemoveLongRoad);

    67

DEF_COMMAND(CmdBuildRoad);

    68

DEF_COMMAND(CmdRemoveRoad);

    69

    70

DEF_COMMAND(CmdBuildRoadDepot);

    71

    72

DEF_COMMAND(CmdBuildAirport);

    73

    74

DEF_COMMAND(CmdBuildDock);

    75

    76

DEF_COMMAND(CmdBuildShipDepot);

    77

    78

DEF_COMMAND(CmdBuildBuoy);

    79

    80

DEF_COMMAND(CmdPlantTree);

    81

    82

DEF_COMMAND(CmdBuildRailVehicle);

    83

DEF_COMMAND(CmdMoveRailVehicle);

    84

    85

DEF_COMMAND(CmdStartStopTrain);

    86

    87

DEF_COMMAND(CmdSellRailWagon);

    88

    89

DEF_COMMAND(CmdSendTrainToDepot);

    90

DEF_COMMAND(CmdForceTrainProceed);

    91

DEF_COMMAND(CmdReverseTrainDirection);

    92

    93

DEF_COMMAND(CmdModifyOrder);

    94

DEF_COMMAND(CmdSkipToOrder);

    95

DEF_COMMAND(CmdDeleteOrder);

    96

DEF_COMMAND(CmdInsertOrder);

    97

DEF_COMMAND(CmdChangeServiceInt);

    98

DEF_COMMAND(CmdRestoreOrderIndex);

    99

   100

DEF_COMMAND(CmdBuildIndustry);

   101

   102

DEF_COMMAND(CmdBuildCompanyHQ);

   103

DEF_COMMAND(CmdSetPlayerFace);

   104

DEF_COMMAND(CmdSetPlayerColor);

   105

   106

DEF_COMMAND(CmdIncreaseLoan);

   107

DEF_COMMAND(CmdDecreaseLoan);

   108

   109

DEF_COMMAND(CmdWantEnginePreview);

   110

   111

DEF_COMMAND(CmdNameVehicle);

   112

DEF_COMMAND(CmdRenameEngine);

   113

   114

DEF_COMMAND(CmdChangeCompanyName);

   115

DEF_COMMAND(CmdChangePresidentName);

   116

   117

DEF_COMMAND(CmdRenameStation);

   118

   119

DEF_COMMAND(CmdSellAircraft);

   120

DEF_COMMAND(CmdStartStopAircraft);

   121

DEF_COMMAND(CmdBuildAircraft);

   122

DEF_COMMAND(CmdSendAircraftToHangar);

   123

DEF_COMMAND(CmdRefitAircraft);

   124

   125

DEF_COMMAND(CmdPlaceSign);

   126

DEF_COMMAND(CmdRenameSign);

   127

   128

DEF_COMMAND(CmdBuildRoadVeh);

   129

DEF_COMMAND(CmdStartStopRoadVeh);

   130

DEF_COMMAND(CmdSellRoadVeh);

   131

DEF_COMMAND(CmdSendRoadVehToDepot);

   132

DEF_COMMAND(CmdTurnRoadVeh);

   133

DEF_COMMAND(CmdRefitRoadVeh);

   134

   135

DEF_COMMAND(CmdPause);

   136

   137

DEF_COMMAND(CmdBuyShareInCompany);

   138

DEF_COMMAND(CmdSellShareInCompany);

   139

DEF_COMMAND(CmdBuyCompany);

   140

   141

DEF_COMMAND(CmdBuildTown);

   142

   143

DEF_COMMAND(CmdRenameTown);

   144

DEF_COMMAND(CmdDoTownAction);

   145

   146

DEF_COMMAND(CmdSetRoadDriveSide);

   147

   148

DEF_COMMAND(CmdChangeDifficultyLevel);

   149

DEF_COMMAND(CmdChangePatchSetting);

   150

   151

DEF_COMMAND(CmdStartStopShip);

   152

DEF_COMMAND(CmdSellShip);

   153

DEF_COMMAND(CmdBuildShip);

   154

DEF_COMMAND(CmdSendShipToDepot);

   155

DEF_COMMAND(CmdRefitShip);

   156

   157

DEF_COMMAND(CmdOrderRefit);

   158

DEF_COMMAND(CmdCloneOrder);

   159

   160

DEF_COMMAND(CmdClearArea);

   161

   162

DEF_COMMAND(CmdGiveMoney);

   163

DEF_COMMAND(CmdMoneyCheat);

   164

DEF_COMMAND(CmdBuildCanal);

   165

DEF_COMMAND(CmdBuildLock);

   166

   167

DEF_COMMAND(CmdPlayerCtrl);

   168

   169

DEF_COMMAND(CmdLevelLand);

   170

   171

DEF_COMMAND(CmdRefitRailVehicle);

   172

   173

DEF_COMMAND(CmdBuildSignalTrack);

   174

DEF_COMMAND(CmdRemoveSignalTrack);

   175

   176

DEF_COMMAND(CmdSetAutoReplace);

   177

   178

DEF_COMMAND(CmdCloneVehicle);

   179

DEF_COMMAND(CmdMassStartStopVehicle);

   180

DEF_COMMAND(CmdDepotSellAllVehicles);

   181

DEF_COMMAND(CmdDepotMassAutoReplace);

   182

   183

DEF_COMMAND(CmdCreateGroup);

   184

DEF_COMMAND(CmdRenameGroup);

   185

DEF_COMMAND(CmdDeleteGroup);

   186

DEF_COMMAND(CmdAddVehicleGroup);

   187

DEF_COMMAND(CmdAddSharedVehicleGroup);

   188

DEF_COMMAND(CmdRemoveAllVehiclesGroup);

   189

DEF_COMMAND(CmdSetGroupReplaceProtection);

   190

   191

DEF_COMMAND(CmdMoveOrder);

   192

DEF_COMMAND(CmdChangeTimetable);

   193

DEF_COMMAND(CmdSetVehicleOnTime);

   194

DEF_COMMAND(CmdAutofillTimetable);

   195

#undef DEF_COMMAND

   196

   197

/**

   198

 * The master command table

   199

 *

   200

 * This table contains all possible CommandProc functions with

   201

 * the flags which belongs to it. The indizes are the same

   202

 * as the value from the CMD_* enums.

   203

 */

   204

static const Command _command_proc_table[] = {

   205

	{CmdBuildRailroadTrack,           CMD_AUTO}, /*   0, CMD_BUILD_RAILROAD_TRACK */

   206

	{CmdRemoveRailroadTrack,          CMD_AUTO}, /*   1, CMD_REMOVE_RAILROAD_TRACK */

   207

	{CmdBuildSingleRail,              CMD_AUTO}, /*   2, CMD_BUILD_SINGLE_RAIL */

   208

	{CmdRemoveSingleRail,             CMD_AUTO}, /*   3, CMD_REMOVE_SINGLE_RAIL */

   209

	{CmdLandscapeClear,                      0}, /*   4, CMD_LANDSCAPE_CLEAR */

   210

	{CmdBuildBridge,                  CMD_AUTO}, /*   5, CMD_BUILD_BRIDGE */

   211

	{CmdBuildRailroadStation,         CMD_AUTO}, /*   6, CMD_BUILD_RAILROAD_STATION */

   212

	{CmdBuildTrainDepot,              CMD_AUTO}, /*   7, CMD_BUILD_TRAIN_DEPOT */

   213

	{CmdBuildSingleSignal,            CMD_AUTO}, /*   8, CMD_BUILD_SIGNALS */

   214

	{CmdRemoveSingleSignal,           CMD_AUTO}, /*   9, CMD_REMOVE_SIGNALS */

   215

	{CmdTerraformLand,                CMD_AUTO}, /*  10, CMD_TERRAFORM_LAND */

   216

	{CmdPurchaseLandArea,             CMD_AUTO}, /*  11, CMD_PURCHASE_LAND_AREA */

   217

	{CmdSellLandArea,                        0}, /*  12, CMD_SELL_LAND_AREA */

   218

	{CmdBuildTunnel,                  CMD_AUTO}, /*  13, CMD_BUILD_TUNNEL */

   219

	{CmdRemoveFromRailroadStation,           0}, /*  14, CMD_REMOVE_FROM_RAILROAD_STATION */

   220

	{CmdConvertRail,                         0}, /*  15, CMD_CONVERT_RAILD */

   221

	{CmdBuildTrainWaypoint,                  0}, /*  16, CMD_BUILD_TRAIN_WAYPOINT */

   222

	{CmdRenameWaypoint,                      0}, /*  17, CMD_RENAME_WAYPOINT */

   223

	{CmdRemoveTrainWaypoint,                 0}, /*  18, CMD_REMOVE_TRAIN_WAYPOINT */

   224

	{NULL,                                   0}, /*  19, unused */

   225

	{NULL,                                   0}, /*  20, unused */

   226

	{CmdBuildRoadStop,                CMD_AUTO}, /*  21, CMD_BUILD_ROAD_STOP */

   227

	{CmdRemoveRoadStop,                      0}, /*  22, CMD_REMOVE_ROAD_STOP */

   228

	{CmdBuildLongRoad,                CMD_AUTO}, /*  23, CMD_BUILD_LONG_ROAD */

   229

	{CmdRemoveLongRoad,               CMD_AUTO}, /*  24, CMD_REMOVE_LONG_ROAD */

   230

	{CmdBuildRoad,                           0}, /*  25, CMD_BUILD_ROAD */

   231

	{CmdRemoveRoad,                          0}, /*  26, CMD_REMOVE_ROAD */

   232

	{CmdBuildRoadDepot,               CMD_AUTO}, /*  27, CMD_BUILD_ROAD_DEPOT */

   233

	{NULL,                                   0}, /*  28, unused */

   234

	{CmdBuildAirport,                 CMD_AUTO}, /*  29, CMD_BUILD_AIRPORT */

   235

	{CmdBuildDock,                    CMD_AUTO}, /*  30, CMD_BUILD_DOCK */

   236

	{CmdBuildShipDepot,               CMD_AUTO}, /*  31, CMD_BUILD_SHIP_DEPOT */

   237

	{CmdBuildBuoy,                    CMD_AUTO}, /*  32, CMD_BUILD_BUOY */

   238

	{CmdPlantTree,                    CMD_AUTO}, /*  33, CMD_PLANT_TREE */

   239

	{CmdBuildRailVehicle,                    0}, /*  34, CMD_BUILD_RAIL_VEHICLE */

   240

	{CmdMoveRailVehicle,                     0}, /*  35, CMD_MOVE_RAIL_VEHICLE */

   241

	{CmdStartStopTrain,                      0}, /*  36, CMD_START_STOP_TRAIN */

   242

	{NULL,                                   0}, /*  37, unused */

   243

	{CmdSellRailWagon,                       0}, /*  38, CMD_SELL_RAIL_WAGON */

   244

	{CmdSendTrainToDepot,                    0}, /*  39, CMD_SEND_TRAIN_TO_DEPOT */

   245

	{CmdForceTrainProceed,                   0}, /*  40, CMD_FORCE_TRAIN_PROCEED */

   246

	{CmdReverseTrainDirection,               0}, /*  41, CMD_REVERSE_TRAIN_DIRECTION */

   247

   248

	{CmdModifyOrder,                         0}, /*  42, CMD_MODIFY_ORDER */

   249

	{CmdSkipToOrder,                         0}, /*  43, CMD_SKIP_TO_ORDER */

   250

	{CmdDeleteOrder,                         0}, /*  44, CMD_DELETE_ORDER */

   251

	{CmdInsertOrder,                         0}, /*  45, CMD_INSERT_ORDER */

   252

   253

	{CmdChangeServiceInt,                    0}, /*  46, CMD_CHANGE_SERVICE_INT */

   254

   255

	{CmdBuildIndustry,                       0}, /*  47, CMD_BUILD_INDUSTRY */

   256

	{CmdBuildCompanyHQ,               CMD_AUTO}, /*  48, CMD_BUILD_COMPANY_HQ */

   257

	{CmdSetPlayerFace,                       0}, /*  49, CMD_SET_PLAYER_FACE */

   258

	{CmdSetPlayerColor,                      0}, /*  50, CMD_SET_PLAYER_COLOR */

   259

   260

	{CmdIncreaseLoan,                        0}, /*  51, CMD_INCREASE_LOAN */

   261

	{CmdDecreaseLoan,                        0}, /*  52, CMD_DECREASE_LOAN */

   262

   263

	{CmdWantEnginePreview,                   0}, /*  53, CMD_WANT_ENGINE_PREVIEW */

   264

   265

	{CmdNameVehicle,                         0}, /*  54, CMD_NAME_VEHICLE */

   266

	{CmdRenameEngine,                        0}, /*  55, CMD_RENAME_ENGINE */

   267

   268

	{CmdChangeCompanyName,                   0}, /*  56, CMD_CHANGE_COMPANY_NAME */

   269

	{CmdChangePresidentName,                 0}, /*  57, CMD_CHANGE_PRESIDENT_NAME */

   270

   271

	{CmdRenameStation,                       0}, /*  58, CMD_RENAME_STATION */

   272

   273

	{CmdSellAircraft,                        0}, /*  59, CMD_SELL_AIRCRAFT */

   274

	{CmdStartStopAircraft,                   0}, /*  60, CMD_START_STOP_AIRCRAFT */

   275

   276

	{CmdBuildAircraft,                       0}, /*  61, CMD_BUILD_AIRCRAFT */

   277

	{CmdSendAircraftToHangar,                0}, /*  62, CMD_SEND_AIRCRAFT_TO_HANGAR */

   278

	{NULL,                                   0}, /*  63, unused */

   279

	{CmdRefitAircraft,                       0}, /*  64, CMD_REFIT_AIRCRAFT */

   280

   281

	{CmdPlaceSign,                           0}, /*  65, CMD_PLACE_SIGN */

   282

	{CmdRenameSign,                          0}, /*  66, CMD_RENAME_SIGN */

   283

   284

	{CmdBuildRoadVeh,                        0}, /*  67, CMD_BUILD_ROAD_VEH */

   285

	{CmdStartStopRoadVeh,                    0}, /*  68, CMD_START_STOP_ROADVEH */

   286

	{CmdSellRoadVeh,                         0}, /*  69, CMD_SELL_ROAD_VEH */

   287

	{CmdSendRoadVehToDepot,                  0}, /*  70, CMD_SEND_ROADVEH_TO_DEPOT */

   288

	{CmdTurnRoadVeh,                         0}, /*  71, CMD_TURN_ROADVEH */

   289

	{CmdRefitRoadVeh,                        0}, /*  72, CMD_REFIT_ROAD_VEH */

   290

   291

	{CmdPause,                      CMD_SERVER}, /*  73, CMD_PAUSE */

   292

   293

	{CmdBuyShareInCompany,                   0}, /*  74, CMD_BUY_SHARE_IN_COMPANY */

   294

	{CmdSellShareInCompany,                  0}, /*  75, CMD_SELL_SHARE_IN_COMPANY */

   295

	{CmdBuyCompany,                          0}, /*  76, CMD_BUY_COMANY */

   296

   297

	{CmdBuildTown,                 CMD_OFFLINE}, /*  77, CMD_BUILD_TOWN */

   298

	{NULL,                                   0}, /*  78, unused */

   299

	{NULL,                                   0}, /*  79, unused */

   300

	{CmdRenameTown,                 CMD_SERVER}, /*  80, CMD_RENAME_TOWN */

   301

	{CmdDoTownAction,                        0}, /*  81, CMD_DO_TOWN_ACTION */

   302

   303

	{CmdSetRoadDriveSide,           CMD_SERVER}, /*  82, CMD_SET_ROAD_DRIVE_SIDE */

   304

	{NULL,                                   0}, /*  83, unused */

   305

	{NULL,                                   0}, /*  84, unused */

   306

	{CmdChangeDifficultyLevel,      CMD_SERVER}, /*  85, CMD_CHANGE_DIFFICULTY_LEVEL */

   307

   308

	{CmdStartStopShip,                       0}, /*  86, CMD_START_STOP_SHIP */

   309

	{CmdSellShip,                            0}, /*  87, CMD_SELL_SHIP */

   310

	{CmdBuildShip,                           0}, /*  88, CMD_BUILD_SHIP */

   311

	{CmdSendShipToDepot,                     0}, /*  89, CMD_SEND_SHIP_TO_DEPOT */

   312

	{NULL,                                   0}, /*  90, unused */

   313

	{CmdRefitShip,                           0}, /*  91, CMD_REFIT_SHIP */

   314

   315

	{NULL,                                   0}, /*  92, unused */

   316

	{NULL,                                   0}, /*  93, unused */

   317

	{NULL,                                   0}, /*  94, unused */

   318

	{NULL,                                   0}, /*  95, unused */

   319

	{NULL,                                   0}, /*  96, unused */

   320

	{NULL,                                   0}, /*  97, unused */

   321

   322

	{CmdOrderRefit,                          0}, /*  98, CMD_ORDER_REFIT */

   323

	{CmdCloneOrder,                          0}, /*  99, CMD_CLONE_ORDER */

   324

   325

	{CmdClearArea,                           0}, /* 100, CMD_CLEAR_AREA */

   326

	{NULL,                                   0}, /* 101, unused */

   327

   328

	{CmdMoneyCheat,                CMD_OFFLINE}, /* 102, CMD_MONEY_CHEAT */

   329

	{CmdBuildCanal,                   CMD_AUTO}, /* 103, CMD_BUILD_CANAL */

   330

	{CmdPlayerCtrl,                          0}, /* 104, CMD_PLAYER_CTRL */

   331

   332

	{CmdLevelLand,                    CMD_AUTO}, /* 105, CMD_LEVEL_LAND */

   333

   334

	{CmdRefitRailVehicle,                    0}, /* 106, CMD_REFIT_RAIL_VEHICLE */

   335

	{CmdRestoreOrderIndex,                   0}, /* 107, CMD_RESTORE_ORDER_INDEX */

   336

	{CmdBuildLock,                    CMD_AUTO}, /* 108, CMD_BUILD_LOCK */

   337

	{NULL,                                   0}, /* 109, unused */

   338

	{CmdBuildSignalTrack,             CMD_AUTO}, /* 110, CMD_BUILD_SIGNAL_TRACK */

   339

	{CmdRemoveSignalTrack,            CMD_AUTO}, /* 111, CMD_REMOVE_SIGNAL_TRACK */

   340

	{NULL,                                   0}, /* 112, unused */

   341

	{CmdGiveMoney,                           0}, /* 113, CMD_GIVE_MONEY */

   342

	{CmdChangePatchSetting,         CMD_SERVER}, /* 114, CMD_CHANGE_PATCH_SETTING */

   343

	{CmdSetAutoReplace,                      0}, /* 115, CMD_SET_AUTOREPLACE */

   344

	{CmdCloneVehicle,                        0}, /* 116, CMD_CLONE_VEHICLE */

   345

	{CmdMassStartStopVehicle,                0}, /* 117, CMD_MASS_START_STOP */

   346

	{CmdDepotSellAllVehicles,                0}, /* 118, CMD_DEPOT_SELL_ALL_VEHICLES */

   347

	{CmdDepotMassAutoReplace,                0}, /* 119, CMD_DEPOT_MASS_AUTOREPLACE */

   348

	{CmdCreateGroup,                         0}, /* 120, CMD_CREATE_GROUP */

   349

	{CmdDeleteGroup,                         0}, /* 121, CMD_DELETE_GROUP */

   350

	{CmdRenameGroup,                         0}, /* 122, CMD_RENAME_GROUP */

   351

	{CmdAddVehicleGroup,                     0}, /* 123, CMD_ADD_VEHICLE_GROUP */

   352

	{CmdAddSharedVehicleGroup,               0}, /* 124, CMD_ADD_SHARE_VEHICLE_GROUP */

   353

	{CmdRemoveAllVehiclesGroup,              0}, /* 125, CMD_REMOVE_ALL_VEHICLES_GROUP */

   354

	{CmdSetGroupReplaceProtection,           0}, /* 126, CMD_SET_GROUP_REPLACE_PROTECTION */

   355

	{CmdMoveOrder,                           0}, /* 127, CMD_MOVE_ORDER */

   356

	{CmdChangeTimetable,                     0}, /* 128, CMD_CHANGE_TIMETABLE */

   357

	{CmdSetVehicleOnTime,                    0}, /* 129, CMD_SET_VEHICLE_ON_TIME */

   358

	{CmdAutofillTimetable,                   0}, /* 130, CMD_AUTOFILL_TIMETABLE */

   359

};

   360

   361

/*!

   362

 * This function range-checks a cmd, and checks if the cmd is not NULL

   363

 *

   364

 * @param cmd The integervalue of a command

   365

 * @return true if the command is valid (and got a CommandProc function)

   366

 */

   367

bool IsValidCommand(uint cmd)

   368

{

   369

	cmd &= 0xFF;

   370

   371

	return

   372

		cmd < lengthof(_command_proc_table) &&

   373

		_command_proc_table[cmd].proc != NULL;

   374

}

   375

   376

/*!

   377

 * This function mask the parameter with 0xFF and returns

   378

 * the flags which belongs to the given command.

   379

 *

   380

 * @param cmd The integer value of the command

   381

 * @return The flags for this command

   382

 * @bug integervalues which are less equals 0xFF and greater than the

   383

 *      size of _command_proc_table can result in an index out of bounce

   384

 *      error (which doesn't happend anyway). Check function #IsValidCommand(). (Progman)

   385

 */

   386

byte GetCommandFlags(uint cmd)

   387

{

   388

	return _command_proc_table[cmd & 0xFF].flags;

   389

}

   390

   391

static int _docommand_recursive;

   392

   393

/*!

   394

 * This function executes a given command with the parameters from the #CommandProc parameter list.

   395

 * Depending on the flags parameter it execute or test a command.

   396

 *

   397

 * @param tile The tile to apply the command on (for the #CommandProc)

   398

 * @param p1 Additional data for the command (for the #CommandProc)

   399

 * @param p2 Additional data for the command (for the #CommandProc)

   400

 * @param flags Flags for the command and how to execute the command

   401

 * @param procc The command-id to execute (a value of the CMD_* enums)

   402

 * @see CommandProc

   403

 */

   404

CommandCost DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint32 procc)

   405

{

   406

	CommandCost res;

   407

	CommandProc *proc;

   408

   409

	/* Do not even think about executing out-of-bounds tile-commands */

   410

	if (tile >= MapSize() || IsTileType(tile, MP_VOID)) {

   411

		_cmd_text = NULL;

   412

		return CMD_ERROR;

   413

	}

   414

   415

	proc = _command_proc_table[procc].proc;

   416

   417

	if (_docommand_recursive == 0) _error_message = INVALID_STRING_ID;

   418

   419

	_docommand_recursive++;

   420

   421

	/* only execute the test call if it's toplevel, or we're not execing. */

   422

	if (_docommand_recursive == 1 || !(flags & DC_EXEC) || (flags & DC_FORCETEST) ) {

   423

		res = proc(tile, flags & ~DC_EXEC, p1, p2);

   424

		if (CmdFailed(res)) {

   425

			res.SetGlobalErrorMessage();

   426

			goto error;

   427

		}

   428

   429

		if (_docommand_recursive == 1 &&

   430

				!(flags & DC_QUERY_COST) &&

   431

				res.GetCost() != 0 &&

   432

				!CheckPlayerHasMoney(res)) {

   433

			goto error;

   434

		}

   435

   436

		if (!(flags & DC_EXEC)) {

   437

			_docommand_recursive--;

   438

			_cmd_text = NULL;

   439

			return res;

   440

		}

   441

	}

   442

   443

	/* Execute the command here. All cost-relevant functions set the expenses type

   444

	 * themselves with "SET_EXPENSES_TYPE(...);" at the beginning of the function */

   445

	res = proc(tile, flags, p1, p2);

   446

	if (CmdFailed(res)) {

   447

		res.SetGlobalErrorMessage();

   448

error:

   449

		_docommand_recursive--;

   450

		_cmd_text = NULL;

   451

		return CMD_ERROR;

   452

	}

   453

   454

	/* if toplevel, subtract the money. */

   455

	if (--_docommand_recursive == 0) {

   456

		SubtractMoneyFromPlayer(res);

   457

		/* XXX - Old AI hack which doesn't use DoCommandDP; update last build coord of player */

   458

		if (tile != 0 && IsValidPlayer(_current_player)) {

   459

			GetPlayer(_current_player)->last_build_coordinate = tile;

   460

		}

   461

	}

   462

   463

	_cmd_text = NULL;

   464

	return res;

   465

}

   466

   467

/*!

   468

 * This functions returns the money which can be used to execute a command.

   469

 * This is either the money of the current player or INT64_MAX if there

   470

 * is no such a player "at the moment" like the server itself.

   471

 *

   472

 * @return The available money of a player or INT64_MAX

   473

 */

   474

Money GetAvailableMoneyForCommand()

   475

{

   476

	PlayerID pid = _current_player;

   477

	if (!IsValidPlayer(pid)) return INT64_MAX;

   478

	return GetPlayer(pid)->player_money;

   479

}

   480

   481

/*!

   482

 * Toplevel network safe docommand function for the current player. Must not be called recursively.

   483

 * The callback is called when the command succeeded or failed. The parameters

   484

 * tile, p1 and p2 are from the #CommandProc function. The paramater cmd is the command to execute.

   485

 * The parameter my_cmd is used to indicate if the command is from a player or the server.

   486

 *

   487

 * @param tile The tile to perform a command on (see #CommandProc)

   488

 * @param p1 Additional data for the command (see #CommandProc)

   489

 * @param p2 Additional data for the command (see #CommandProc)

   490

 * @param callback A callback function to call after the command is finished

   491

 * @param cmd The command to execute (a CMD_* value)

   492

 * @param my_cmd indicator if the command is from a player or server (to display error messages for a user)

   493

 * @return true if the command succeeded, else false

   494

 */

   495

bool DoCommandP(TileIndex tile, uint32 p1, uint32 p2, CommandCallback *callback, uint32 cmd, bool my_cmd)

   496

{

   497

	CommandCost res, res2;

   498

	CommandProc *proc;

   499