1

/* $Id$ */

     2

     3

/** @file command.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "landscape.h"

     8

#include "tile_map.h"

     9

#include "gui.h"

    10

#include "command_func.h"

    11

#include "network/network.h"

    12

#include "variables.h"

    13

#include "genworld.h"

    14

#include "newgrf_storage.h"

    15

#include "strings_func.h"

    16

#include "gfx_func.h"

    17

#include "functions.h"

    18

#include "town.h"

    19

#include "date_func.h"

    20

#include "debug.h"

    21

#include "player_func.h"

    22

#include "player_base.h"

    23

#include "signal_func.h"

    24

    25

#include "table/strings.h"

    26

    27

const char *_cmd_text = NULL;

    28

StringID _error_message;

    29

    30

/**

    31

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

    32

 *

    33

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

    34

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

    35

 * type.

    36

 *

    37

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

    38

 */

    39

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

    40

    41

DEF_COMMAND(CmdBuildRailroadTrack);

    42

DEF_COMMAND(CmdRemoveRailroadTrack);

    43

DEF_COMMAND(CmdBuildSingleRail);

    44

DEF_COMMAND(CmdRemoveSingleRail);

    45

    46

DEF_COMMAND(CmdLandscapeClear);

    47

    48

DEF_COMMAND(CmdBuildBridge);

    49

    50

DEF_COMMAND(CmdBuildRailroadStation);

    51

DEF_COMMAND(CmdRemoveFromRailroadStation);

    52

DEF_COMMAND(CmdConvertRail);

    53

    54

DEF_COMMAND(CmdBuildSingleSignal);

    55

DEF_COMMAND(CmdRemoveSingleSignal);

    56

    57

DEF_COMMAND(CmdTerraformLand);

    58

    59

DEF_COMMAND(CmdPurchaseLandArea);

    60

DEF_COMMAND(CmdSellLandArea);

    61

    62

DEF_COMMAND(CmdBuildTunnel);

    63

    64

DEF_COMMAND(CmdBuildTrainDepot);

    65

DEF_COMMAND(CmdBuildTrainWaypoint);

    66

DEF_COMMAND(CmdRenameWaypoint);

    67

DEF_COMMAND(CmdRemoveTrainWaypoint);

    68

    69

DEF_COMMAND(CmdBuildRoadStop);

    70

DEF_COMMAND(CmdRemoveRoadStop);

    71

    72

DEF_COMMAND(CmdBuildLongRoad);

    73

DEF_COMMAND(CmdRemoveLongRoad);

    74

DEF_COMMAND(CmdBuildRoad);

    75

DEF_COMMAND(CmdRemoveRoad);

    76

    77

DEF_COMMAND(CmdBuildRoadDepot);

    78

    79

DEF_COMMAND(CmdBuildAirport);

    80

    81

DEF_COMMAND(CmdBuildDock);

    82

    83

DEF_COMMAND(CmdBuildShipDepot);

    84

    85

DEF_COMMAND(CmdBuildBuoy);

    86

    87

DEF_COMMAND(CmdPlantTree);

    88

    89

DEF_COMMAND(CmdBuildRailVehicle);

    90

DEF_COMMAND(CmdMoveRailVehicle);

    91

    92

DEF_COMMAND(CmdStartStopTrain);

    93

    94

DEF_COMMAND(CmdSellRailWagon);

    95

    96

DEF_COMMAND(CmdSendTrainToDepot);

    97

DEF_COMMAND(CmdForceTrainProceed);

    98

DEF_COMMAND(CmdReverseTrainDirection);

    99

   100

DEF_COMMAND(CmdModifyOrder);

   101

DEF_COMMAND(CmdSkipToOrder);

   102

DEF_COMMAND(CmdDeleteOrder);

   103

DEF_COMMAND(CmdInsertOrder);

   104

DEF_COMMAND(CmdChangeServiceInt);

   105

DEF_COMMAND(CmdRestoreOrderIndex);

   106

   107

DEF_COMMAND(CmdBuildIndustry);

   108

   109

DEF_COMMAND(CmdBuildCompanyHQ);

   110

DEF_COMMAND(CmdSetPlayerFace);

   111

DEF_COMMAND(CmdSetPlayerColor);

   112

   113

DEF_COMMAND(CmdIncreaseLoan);

   114

DEF_COMMAND(CmdDecreaseLoan);

   115

   116

DEF_COMMAND(CmdWantEnginePreview);

   117

   118

DEF_COMMAND(CmdNameVehicle);

   119

DEF_COMMAND(CmdRenameEngine);

   120

   121

DEF_COMMAND(CmdChangeCompanyName);

   122

DEF_COMMAND(CmdChangePresidentName);

   123

   124

DEF_COMMAND(CmdRenameStation);

   125

   126

DEF_COMMAND(CmdSellAircraft);

   127

DEF_COMMAND(CmdStartStopAircraft);

   128

DEF_COMMAND(CmdBuildAircraft);

   129

DEF_COMMAND(CmdSendAircraftToHangar);

   130

DEF_COMMAND(CmdRefitAircraft);

   131

   132

DEF_COMMAND(CmdPlaceSign);

   133

DEF_COMMAND(CmdRenameSign);

   134

   135

DEF_COMMAND(CmdBuildRoadVeh);

   136

DEF_COMMAND(CmdStartStopRoadVeh);

   137

DEF_COMMAND(CmdSellRoadVeh);

   138

DEF_COMMAND(CmdSendRoadVehToDepot);

   139

DEF_COMMAND(CmdTurnRoadVeh);

   140

DEF_COMMAND(CmdRefitRoadVeh);

   141

   142

DEF_COMMAND(CmdPause);

   143

   144

DEF_COMMAND(CmdBuyShareInCompany);

   145

DEF_COMMAND(CmdSellShareInCompany);

   146

DEF_COMMAND(CmdBuyCompany);

   147

   148

DEF_COMMAND(CmdBuildTown);

   149

   150

DEF_COMMAND(CmdRenameTown);

   151

DEF_COMMAND(CmdDoTownAction);

   152

   153

DEF_COMMAND(CmdSetRoadDriveSide);

   154

   155

DEF_COMMAND(CmdChangeDifficultyLevel);

   156

DEF_COMMAND(CmdChangePatchSetting);

   157

   158

DEF_COMMAND(CmdStartStopShip);

   159

DEF_COMMAND(CmdSellShip);

   160

DEF_COMMAND(CmdBuildShip);

   161

DEF_COMMAND(CmdSendShipToDepot);

   162

DEF_COMMAND(CmdRefitShip);

   163

   164

DEF_COMMAND(CmdOrderRefit);

   165

DEF_COMMAND(CmdCloneOrder);

   166

   167

DEF_COMMAND(CmdClearArea);

   168

   169

DEF_COMMAND(CmdGiveMoney);

   170

DEF_COMMAND(CmdMoneyCheat);

   171

DEF_COMMAND(CmdBuildCanal);

   172

DEF_COMMAND(CmdBuildLock);

   173

   174

DEF_COMMAND(CmdPlayerCtrl);

   175

   176

DEF_COMMAND(CmdLevelLand);

   177

   178

DEF_COMMAND(CmdRefitRailVehicle);

   179

   180

DEF_COMMAND(CmdBuildSignalTrack);

   181

DEF_COMMAND(CmdRemoveSignalTrack);

   182

   183

DEF_COMMAND(CmdSetAutoReplace);

   184

   185

DEF_COMMAND(CmdCloneVehicle);

   186

DEF_COMMAND(CmdMassStartStopVehicle);

   187

DEF_COMMAND(CmdDepotSellAllVehicles);

   188

DEF_COMMAND(CmdDepotMassAutoReplace);

   189

   190

DEF_COMMAND(CmdCreateGroup);

   191

DEF_COMMAND(CmdRenameGroup);

   192

DEF_COMMAND(CmdDeleteGroup);

   193

DEF_COMMAND(CmdAddVehicleGroup);

   194

DEF_COMMAND(CmdAddSharedVehicleGroup);

   195

DEF_COMMAND(CmdRemoveAllVehiclesGroup);

   196

DEF_COMMAND(CmdSetGroupReplaceProtection);

   197

   198

DEF_COMMAND(CmdMoveOrder);

   199

DEF_COMMAND(CmdChangeTimetable);

   200

DEF_COMMAND(CmdSetVehicleOnTime);

   201

DEF_COMMAND(CmdAutofillTimetable);

   202

#undef DEF_COMMAND

   203

   204

/**

   205

 * The master command table

   206

 *

   207

 * This table contains all possible CommandProc functions with

   208

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

   209

 * as the value from the CMD_* enums.

   210

 */

   211

static const Command _command_proc_table[] = {

   231

   239

   248

   351

};

   352

   353

/*!

   354

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

   355

 *

   356

 * @param cmd The integervalue of a command

   357

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

   358

 */

   359

bool IsValidCommand(uint cmd)

   360

{

   361

	cmd &= 0xFF;

   362

   363

	return

   364

		cmd < lengthof(_command_proc_table) &&

   365

		_command_proc_table[cmd].proc != NULL;

   366

}

   367

   368

/*!

   369

 * This function mask the parameter with 0xFF and returns

   370

 * the flags which belongs to the given command.

   371

 *

   372

 * @param cmd The integer value of the command

   373

 * @return The flags for this command

   374

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

   375

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

   376

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

   377

 */

   378

byte GetCommandFlags(uint cmd)

   379

{

   380

	return _command_proc_table[cmd & 0xFF].flags;

   381

}

   382

   383

static int _docommand_recursive = 0;

   384

   385

/*!

   386

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

   387

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

   388

 *

   389

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

   390

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

   391

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

   392

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

   393

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

   394

 * @see CommandProc

   395

 */

   396

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

   397

{

   398

	CommandCost res;

   399

	CommandProc *proc;

   400

   401

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

   402

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

   403

		_cmd_text = NULL;

   404

		return CMD_ERROR;

   405

	}

   406

   407

	proc = _command_proc_table[procc].proc;

   408

   409

	if (_docommand_recursive == 0) _error_message = INVALID_STRING_ID;

   410

   411

	_docommand_recursive++;

   412

   413

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

   415

		SetTownRatingTestMode(true);

   416

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

   417

		SetTownRatingTestMode(false);

   418

		if (CmdFailed(res)) {

   419

			res.SetGlobalErrorMessage();

   420

			goto error;

   421

		}

   422

   423

		if (_docommand_recursive == 1 &&

   424

				!(flags & DC_QUERY_COST) &&

   426

				res.GetCost() != 0 &&

   427

				!CheckPlayerHasMoney(res)) {

   428

			goto error;

   429

		}

   430

   431

		if (!(flags & DC_EXEC)) {

   432

			_docommand_recursive--;

   433

			_cmd_text = NULL;

   434

			return res;

   435

		}

   436

	}

   437

   438

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

   439

	 * themselves to the cost object at some point */

   440

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

   441

	if (CmdFailed(res)) {

   442

		res.SetGlobalErrorMessage();

   443

error:

   444

		_docommand_recursive--;

   445

		_cmd_text = NULL;

   446

		return CMD_ERROR;

   447

	}

   448

   449

	/* if toplevel, subtract the money. */

   451

		SubtractMoneyFromPlayer(res);

   452

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

   453

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

   454

			GetPlayer(_current_player)->last_build_coordinate = tile;

   455

		}

   456

	}

   457

   458

	_cmd_text = NULL;

   459

	return res;

   460

}

   461

   462

/*!

   463

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

   464

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

   465

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

   466

 *

   467

 * @return The available money of a player or INT64_MAX

   468

 */

   469

Money GetAvailableMoneyForCommand()

   470

{

   471

	PlayerID pid = _current_player;

   472

	if (!IsValidPlayer(pid)) return INT64_MAX;

   473

	return GetPlayer(pid)->player_money;

   474

}

   475

   476

/*!

   477

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

   478

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

   479

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

   480

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

   481

 *

   482

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

   483

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

   484

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

   485

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

   486

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

   487

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

   488

 * @return true if the command succeeded, else false

   489

 */

   490

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

   491

{

   492

	CommandCost res, res2;

   493

	CommandProc *proc;

   494

	uint32 flags;

   495

	bool notest;

   496

	StringID error_part1;

   497

   498

	int x = TileX(tile) * TILE_SIZE;