1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "gui.h"

     6

#include "command.h"

     7

#include "player.h"

     8

#include "network.h"

     9

    10

const char* _cmd_text = NULL;

    11

    12

#define DEF_COMMAND(yyyy) int32 yyyy(int x, int y, uint32 flags, uint32 p1, uint32 p2)

    13

    14

DEF_COMMAND(CmdBuildRailroadTrack);

    15

DEF_COMMAND(CmdRemoveRailroadTrack);

    16

DEF_COMMAND(CmdBuildSingleRail);

    17

DEF_COMMAND(CmdRemoveSingleRail);

    18

    19

DEF_COMMAND(CmdLandscapeClear);

    20

    21

DEF_COMMAND(CmdBuildBridge);

    22

    23

DEF_COMMAND(CmdBuildRailroadStation);

    24

DEF_COMMAND(CmdRemoveFromRailroadStation);

    25

DEF_COMMAND(CmdConvertRail);

    26

    27

DEF_COMMAND(CmdBuildSingleSignal);

    28

DEF_COMMAND(CmdRemoveSingleSignal);

    29

    30

DEF_COMMAND(CmdTerraformLand);

    31

    32

DEF_COMMAND(CmdPurchaseLandArea);

    33

DEF_COMMAND(CmdSellLandArea);

    34

    35

DEF_COMMAND(CmdBuildTunnel);

    36

    37

DEF_COMMAND(CmdBuildTrainDepot);

    38

DEF_COMMAND(CmdBuildTrainWaypoint);

    39

DEF_COMMAND(CmdRenameWaypoint);

    40

DEF_COMMAND(CmdRemoveTrainWaypoint);

    41

    42

DEF_COMMAND(CmdBuildRoadStop);

    43

    44

DEF_COMMAND(CmdBuildLongRoad);

    45

DEF_COMMAND(CmdRemoveLongRoad);

    46

DEF_COMMAND(CmdBuildRoad);

    47

DEF_COMMAND(CmdRemoveRoad);

    48

    49

DEF_COMMAND(CmdBuildRoadDepot);

    50

    51

DEF_COMMAND(CmdBuildAirport);

    52

    53

DEF_COMMAND(CmdBuildDock);

    54

    55

DEF_COMMAND(CmdBuildShipDepot);

    56

    57

DEF_COMMAND(CmdBuildBuoy);

    58

    59

DEF_COMMAND(CmdPlantTree);

    60

    61

DEF_COMMAND(CmdBuildRailVehicle);

    62

DEF_COMMAND(CmdMoveRailVehicle);

    63

    64

DEF_COMMAND(CmdStartStopTrain);

    65

    66

DEF_COMMAND(CmdSellRailWagon);

    67

    68

DEF_COMMAND(CmdSendTrainToDepot);

    69

DEF_COMMAND(CmdForceTrainProceed);

    70

DEF_COMMAND(CmdReverseTrainDirection);

    71

    72

DEF_COMMAND(CmdModifyOrder);

    73

DEF_COMMAND(CmdSkipOrder);

    74

DEF_COMMAND(CmdDeleteOrder);

    75

DEF_COMMAND(CmdInsertOrder);

    76

DEF_COMMAND(CmdChangeTrainServiceInt);

    77

DEF_COMMAND(CmdRestoreOrderIndex);

    78

    79

DEF_COMMAND(CmdBuildIndustry);

    80

    81

DEF_COMMAND(CmdBuildCompanyHQ);

    82

DEF_COMMAND(CmdSetPlayerFace);

    83

DEF_COMMAND(CmdSetPlayerColor);

    84

    85

DEF_COMMAND(CmdIncreaseLoan);

    86

DEF_COMMAND(CmdDecreaseLoan);

    87

    88

DEF_COMMAND(CmdWantEnginePreview);

    89

    90

DEF_COMMAND(CmdNameVehicle);

    91

DEF_COMMAND(CmdRenameEngine);

    92

    93

DEF_COMMAND(CmdChangeCompanyName);

    94

DEF_COMMAND(CmdChangePresidentName);

    95

    96

DEF_COMMAND(CmdRenameStation);

    97

    98

DEF_COMMAND(CmdSellAircraft);

    99

DEF_COMMAND(CmdStartStopAircraft);

   100

DEF_COMMAND(CmdBuildAircraft);

   101

DEF_COMMAND(CmdSendAircraftToHangar);

   102

DEF_COMMAND(CmdChangeAircraftServiceInt);

   103

DEF_COMMAND(CmdRefitAircraft);

   104

   105

DEF_COMMAND(CmdPlaceSign);

   106

DEF_COMMAND(CmdRenameSign);

   107

   108

DEF_COMMAND(CmdBuildRoadVeh);

   109

DEF_COMMAND(CmdStartStopRoadVeh);

   110

DEF_COMMAND(CmdSellRoadVeh);

   111

DEF_COMMAND(CmdSendRoadVehToDepot);

   112

DEF_COMMAND(CmdTurnRoadVeh);

   113

DEF_COMMAND(CmdChangeRoadVehServiceInt);

   114

   115

DEF_COMMAND(CmdPause);

   116

   117

DEF_COMMAND(CmdBuyShareInCompany);

   118

DEF_COMMAND(CmdSellShareInCompany);

   119

DEF_COMMAND(CmdBuyCompany);

   120

   121

DEF_COMMAND(CmdBuildTown);

   122

   123

DEF_COMMAND(CmdRenameTown);

   124

DEF_COMMAND(CmdDoTownAction);

   125

   126

DEF_COMMAND(CmdSetRoadDriveSide);

   127

   128

DEF_COMMAND(CmdChangeDifficultyLevel);

   129

DEF_COMMAND(CmdChangePatchSetting);

   130

   131

DEF_COMMAND(CmdStartStopShip);

   132

DEF_COMMAND(CmdSellShip);

   133

DEF_COMMAND(CmdBuildShip);

   134

DEF_COMMAND(CmdSendShipToDepot);

   135

DEF_COMMAND(CmdChangeShipServiceInt);

   136

DEF_COMMAND(CmdRefitShip);

   137

   138

DEF_COMMAND(CmdCloneOrder);

   139

   140

DEF_COMMAND(CmdClearArea);

   141

   142

DEF_COMMAND(CmdGiveMoney);

   143

DEF_COMMAND(CmdMoneyCheat);

   144

DEF_COMMAND(CmdBuildCanal);

   145

DEF_COMMAND(CmdBuildLock);

   146

   147

DEF_COMMAND(CmdPlayerCtrl);

   148

   149

DEF_COMMAND(CmdLevelLand);

   150

   151

DEF_COMMAND(CmdRefitRailVehicle);

   152

   153

DEF_COMMAND(CmdBuildSignalTrack);

   154

DEF_COMMAND(CmdRemoveSignalTrack);

   155

   156

DEF_COMMAND(CmdReplaceVehicle);

   157

   158

/* The master command table */

   159

static const Command _command_proc_table[] = {

   160

	{CmdBuildRailroadTrack,                  0}, /*   0 */

   161

	{CmdRemoveRailroadTrack,                 0}, /*   1 */

   162

	{CmdBuildSingleRail,                     0}, /*   2 */

   163

	{CmdRemoveSingleRail,                    0}, /*   3 */

   164

	{CmdLandscapeClear,                      0}, /*   4 */

   165

	{CmdBuildBridge,                         0}, /*   5 */

   166

	{CmdBuildRailroadStation,                0}, /*   6 */

   167

	{CmdBuildTrainDepot,                     0}, /*   7 */

   168

	{CmdBuildSingleSignal,                   0}, /*   8 */

   169

	{CmdRemoveSingleSignal,                  0}, /*   9 */

   170

	{CmdTerraformLand,                       0}, /*  10 */

   171

	{CmdPurchaseLandArea,                    0}, /*  11 */

   172

	{CmdSellLandArea,                        0}, /*  12 */

   173

	{CmdBuildTunnel,                         0}, /*  13 */

   174

	{CmdRemoveFromRailroadStation,           0}, /*  14 */

   175

	{CmdConvertRail,                         0}, /*  15 */

   176

	{CmdBuildTrainWaypoint,                  0}, /*  16 */

   177

	{CmdRenameWaypoint,                      0}, /*  17 */

   178

	{CmdRemoveTrainWaypoint,                 0}, /*  18 */

   179

	{NULL,                                   0}, /*  19 */

   180

	{NULL,                                   0}, /*  20 */

   181

	{CmdBuildRoadStop,                       0}, /*  21 */

   182

	{NULL,                                   0}, /*  22 */

   183

	{CmdBuildLongRoad,                       0}, /*  23 */

   184

	{CmdRemoveLongRoad,                      0}, /*  24 */

   185

	{CmdBuildRoad,                           0}, /*  25 */

   186

	{CmdRemoveRoad,                          0}, /*  26 */

   187

	{CmdBuildRoadDepot,                      0}, /*  27 */

   188

	{NULL,                                   0}, /*  28 */

   189

	{CmdBuildAirport,                        0}, /*  29 */

   190

	{CmdBuildDock,                           0}, /*  30 */

   191

	{CmdBuildShipDepot,                      0}, /*  31 */

   192

	{CmdBuildBuoy,                           0}, /*  32 */

   193

	{CmdPlantTree,                           0}, /*  33 */

   194

	{CmdBuildRailVehicle,                    0}, /*  34 */

   195

	{CmdMoveRailVehicle,                     0}, /*  35 */

   196

	{CmdStartStopTrain,                      0}, /*  36 */

   197

	{NULL,                                   0}, /*  37 */

   198

	{CmdSellRailWagon,                       0}, /*  38 */

   199

	{CmdSendTrainToDepot,                    0}, /*  39 */

   200

	{CmdForceTrainProceed,                   0}, /*  40 */

   201

	{CmdReverseTrainDirection,               0}, /*  41 */

   202

   203

	{CmdModifyOrder,                         0}, /*  42 */

   204

	{CmdSkipOrder,                           0}, /*  43 */

   205

	{CmdDeleteOrder,                         0}, /*  44 */

   206

	{CmdInsertOrder,                         0}, /*  45 */

   207

   208

	{CmdChangeTrainServiceInt,               0}, /*  46 */

   209

   210

	{CmdBuildIndustry,                       0}, /*  47 */

   211

	{CmdBuildCompanyHQ,                      0}, /*  48 */

   212

	{CmdSetPlayerFace,                       0}, /*  49 */

   213

	{CmdSetPlayerColor,                      0}, /*  50 */

   214

   215

	{CmdIncreaseLoan,                        0}, /*  51 */

   216

	{CmdDecreaseLoan,                        0}, /*  52 */

   217

   218

	{CmdWantEnginePreview,                   0}, /*  53 */

   219

   220

	{CmdNameVehicle,                         0}, /*  54 */

   221

	{CmdRenameEngine,                        0}, /*  55 */

   222

   223

	{CmdChangeCompanyName,                   0}, /*  56 */

   224

	{CmdChangePresidentName,                 0}, /*  57 */

   225

   226

	{CmdRenameStation,                       0}, /*  58 */

   227

   228

	{CmdSellAircraft,                        0}, /*  59 */

   229

	{CmdStartStopAircraft,                   0}, /*  60 */

   230

   231

	{CmdBuildAircraft,                       0}, /*  61 */

   232

	{CmdSendAircraftToHangar,                0}, /*  62 */

   233

	{CmdChangeAircraftServiceInt,            0}, /*  63 */

   234

	{CmdRefitAircraft,                       0}, /*  64 */

   235

   236

	{CmdPlaceSign,                           0}, /*  65 */

   237

	{CmdRenameSign,                          0}, /*  66 */

   238

   239

	{CmdBuildRoadVeh,                        0}, /*  67 */

   240

	{CmdStartStopRoadVeh,                    0}, /*  68 */

   241

	{CmdSellRoadVeh,                         0}, /*  69 */

   242

	{CmdSendRoadVehToDepot,                  0}, /*  70 */

   243

	{CmdTurnRoadVeh,                         0}, /*  71 */

   244

	{CmdChangeRoadVehServiceInt,             0}, /*  72 */

   245

   246

	{CmdPause,                      CMD_SERVER}, /*  73 */

   247

   248

	{CmdBuyShareInCompany,                   0}, /*  74 */

   249

	{CmdSellShareInCompany,                  0}, /*  75 */

   250

	{CmdBuyCompany,                          0}, /*  76 */

   251

   252

	{CmdBuildTown,                 CMD_OFFLINE}, /*  77 */

   253

	{NULL,                                   0}, /*  78 */

   254

	{NULL,                                   0}, /*  79 */

   255

	{CmdRenameTown,                 CMD_SERVER}, /*  80 */

   256

	{CmdDoTownAction,                        0}, /*  81 */

   257

   258

	{CmdSetRoadDriveSide,           CMD_SERVER}, /*  82 */

   259

	{NULL,                                   0}, /*  83 */

   260

	{NULL,                                   0}, /*  84 */

   261

	{CmdChangeDifficultyLevel,      CMD_SERVER}, /*  85 */

   262

   263

	{CmdStartStopShip,                       0}, /*  86 */

   264

	{CmdSellShip,                            0}, /*  87 */

   265

	{CmdBuildShip,                           0}, /*  88 */

   266

	{CmdSendShipToDepot,                     0}, /*  89 */

   267

	{CmdChangeShipServiceInt,                0}, /*  90 */

   268

	{CmdRefitShip,                           0}, /*  91 */

   269

   270

	{NULL,                                   0}, /*  92 */

   271

	{NULL,                                   0}, /*  93 */

   272

	{NULL,                                   0}, /*  94 */

   273

	{NULL,                                   0}, /*  95 */

   274

	{NULL,                                   0}, /*  96 */

   275

	{NULL,                                   0}, /*  97 */

   276

	{NULL,                                   0}, /*  98 */

   277

   278

	{CmdCloneOrder,                          0}, /*  99 */

   279

   280

	{CmdClearArea,                           0}, /* 100 */

   281

	{NULL,                                   0}, /* 101 */

   282

   283

	{CmdMoneyCheat,                CMD_OFFLINE}, /* 102 */

   284

	{CmdBuildCanal,                          0}, /* 103 */

   285

	{CmdPlayerCtrl,                          0}, /* 104 */

   286

   287

	{CmdLevelLand,                           0}, /* 105 */

   288

   289

	{CmdRefitRailVehicle,                    0}, /* 106 */

   290

	{CmdRestoreOrderIndex,                   0}, /* 107 */

   291

	{CmdBuildLock,                           0}, /* 108 */

   292

	{NULL,                                   0}, /* 109 */

   293

	{CmdBuildSignalTrack,                    0}, /* 110 */

   294

	{CmdRemoveSignalTrack,                   0}, /* 111 */

   295

	{NULL,                                   0}, /* 112 */

   296

	{CmdGiveMoney,                           0}, /* 113 */

   297

	{CmdChangePatchSetting,         CMD_SERVER}, /* 114 */

   298

	{CmdReplaceVehicle,                      0}, /* 115 */

   299

};

   300

   301

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

   302

bool IsValidCommand(uint cmd)

   303

{

   304

	cmd = cmd & 0xFF;

   305

   306

	if (cmd >= lengthof(_command_proc_table) || _command_proc_table[cmd].proc == NULL)

   307

		return false;

   308

   309

	return true;

   310

}

   311

   312

byte GetCommandFlags(uint cmd) {return _command_proc_table[cmd & 0xFF].flags;}

   313

   314

int32 DoCommandByTile(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint procc)

   315

{

   316

	return DoCommand(TileX(tile) * 16, TileY(tile) * 16, p1, p2, flags, procc);

   317

}

   318

   319

   320

//extern void _stdcall Sleep(int s);

   321

   322

int32 DoCommand(int x, int y, uint32 p1, uint32 p2, uint32 flags, uint procc)

   323

{

   324

	int32 res;

   325

	CommandProc *proc;

   326

   327

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

   328

	if (TILE_FROM_XY(x,y) > MapSize()) {

   329

		_cmd_text = NULL;

   330

		return CMD_ERROR;

   331

	}

   332

   333

	proc = _command_proc_table[procc].proc;

   334

   335

	if (_docommand_recursive == 0) {

   336

		_error_message = INVALID_STRING_ID;

   337

		// update last build coord of player

   338

		if ( (x|y) != 0 && _current_player < MAX_PLAYERS) {

   339

			DEREF_PLAYER(_current_player)->last_build_coordinate = TILE_FROM_XY(x,y);

   340

		}

   341

	}

   342

   343

	_docommand_recursive++;

   344

   345

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

   346

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

   347

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

   348

		if (CmdFailed(res)) {

   349

			if (res & 0xFFFF) _error_message = res & 0xFFFF;

   350

			goto error;

   351

		}

   352

   353

		if (_docommand_recursive == 1) {

   354

			if (!(flags&DC_QUERY_COST) && res != 0 && !CheckPlayerHasMoney(res))

   355

				goto error;

   356

		}

   357

   358

		if (!(flags & DC_EXEC)) {

   359

			_docommand_recursive--;

   360

			_cmd_text = NULL;

   361

			return res;

   362

		}

   363

	}

   364

   365

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

   366

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

   367

	res = proc(x, y, flags, p1, p2);

   368

	if (CmdFailed(res)) {

   369

		if (res & 0xFFFF) _error_message = res & 0xFFFF;

   370

error:

   371

		_docommand_recursive--;

   372

		_cmd_text = NULL;

   373

		return CMD_ERROR;

   374

	}

   375

   376

	// if toplevel, subtract the money.

   377

	if (--_docommand_recursive == 0) {

   378

		SubtractMoneyFromPlayer(res);

   379

	}

   380

   381

	_cmd_text = NULL;

   382

	return res;

   383

}

   384

   385

int32 GetAvailableMoneyForCommand(void)

   386

{

   387

	PlayerID pid = _current_player;

   388

	if (pid >= MAX_PLAYERS) return 0x7FFFFFFF; // max int

   389

	return DEREF_PLAYER(pid)->player_money;

   390

}

   391

   392

// toplevel network safe docommand function for the current player. must not be called recursively.

   393

// the callback is called when the command succeeded or failed.

   394

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

   395

{

   396

	int32 res = 0,res2;

   397

	CommandProc *proc;

   398

	uint32 flags;

   399

	bool notest;

   400

   401

	int x = TileX(tile) * 16;

   402

	int y = TileY(tile) * 16;

   403

   404

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

   405

	if (tile > MapSize()) {

   406

		_cmd_text = NULL;

   407

		return false;

   408

	}

   409

   410

	assert(_docommand_recursive == 0);

   411

   412

	_error_message = INVALID_STRING_ID;

   413

	_error_message_2 = cmd >> 16;

   414

	_additional_cash_required = 0;

   415

   416

	/** Spectator has no rights except for the dedicated server which

   417

	 * is a spectator but is the server, so can do anything */

   418

	if (_current_player == OWNER_SPECTATOR && !_network_dedicated) {

   419

		ShowErrorMessage(_error_message, _error_message_2, x, y);

   420

		_cmd_text = NULL;

   421

		return false;

   422

	}

   423

   424

	flags = 0;

   425

	if (cmd & CMD_AUTO) flags |= DC_AUTO;

   426

	if (cmd & CMD_NO_WATER) flags |= DC_NO_WATER;

   427

   428

	// get pointer to command handler

   429

	assert((cmd & 0xFF) < lengthof(_command_proc_table));

   430

	proc = _command_proc_table[cmd & 0xFF].proc;

   431

   432

	// Some commands have a different output in dryrun than the realrun

   433

	//  e.g.: if you demolish a whole town, the dryrun would say okay.

   434

	//  but by really destroying, your rating drops and at a certain point

   435

	//  it will fail. so res and res2 are different

   436

	// CMD_REMOVE_ROAD: This command has special local authority

   437

	// restrictions which may cause the test run to fail (the previous

   438

	// road fragments still stay there and the town won't let you

   439

	// disconnect the road system), but the exec will succeed and this

   440

	// fact will trigger an assertion failure. --pasky

   441

	notest =

   442

		(cmd & 0xFF) == CMD_CLEAR_AREA ||

   443

		(cmd & 0xFF) == CMD_CONVERT_RAIL ||

   444

		(cmd & 0xFF) == CMD_LEVEL_LAND ||

   445

		(cmd & 0xFF) == CMD_REMOVE_ROAD ||

   446

		(cmd & 0xFF) == CMD_REMOVE_LONG_ROAD;

   447

   448

	_docommand_recursive = 1;

   449

   450

	// cost estimation only?

   451

	if (_shift_pressed && _current_player == _local_player && !(cmd & (CMD_NETWORK_COMMAND | CMD_SHOW_NO_ERROR))) {

   452

		// estimate the cost.

   453

		res = proc(x, y, flags, p1, p2);

   454

		if (CmdFailed(res)) {

   455

			if (res & 0xFFFF) _error_message = res & 0xFFFF;

   456

			ShowErrorMessage(_error_message, _error_message_2, x, y);

   457

		} else {

   458

			ShowEstimatedCostOrIncome(res, x, y);

   459

		}

   460

   461

		_docommand_recursive = 0;

   462

		_cmd_text = NULL;

   463

		return false;

   464

	}

   465

   466

   467

	if (!((cmd & CMD_NO_TEST_IF_IN_NETWORK) && _networking)) {

   468

		// first test if the command can be executed.

   469

		res = proc(x,y, flags, p1, p2);

   470

		if (CmdFailed(res)) {

   471

			if (res & 0xFFFF) _error_message = res & 0xFFFF;

   472

			goto show_error;

   473

		}

   474

		// no money? Only check if notest is off

   475

		if (!notest && res != 0 && !CheckPlayerHasMoney(res)) goto show_error;

   476

	}

   477

   478

#ifdef ENABLE_NETWORK

   479

	/** If we are in network, and the command is not from the network

   480

	 * send it to the command-queue and abort execution

   481

	 * If we are a dedicated server temporarily switch local player, otherwise

   482

	 * the other parties won't be able to execute our command and will desync.

   483

	 * @todo Rewrite dedicated server to something more than a dirty hack!

   484

	 */

   485

	if (_networking && !(cmd & CMD_NETWORK_COMMAND)) {

   486

		if (_network_dedicated) _local_player = 0;

   487

		NetworkSend_Command(tile, p1, p2, cmd, callback);

   488

		if (_network_dedicated) _local_player = OWNER_SPECTATOR;

   489

		_docommand_recursive = 0;

   490

		_cmd_text = NULL;

   491

		return true;

   492

	}

   493

#endif /* ENABLE_NETWORK */

   494

   495

	// update last build coordinate of player.

   496

	if ( tile != 0 && _current_player < MAX_PLAYERS) DEREF_PLAYER(_current_player)->last_build_coordinate = tile;

   497

   498

	/* Actually try and execute the command. If no cost-type is given

   499

	 * use the construction one */

   500

	_yearly_expenses_type = EXPENSES_CONSTRUCTION;

   501

	res2 = proc(x,y, flags|DC_EXEC, p1, p2);

   502

   503

	// If notest is on, it means the result of the test can be different than

   504

	//   the real command.. so ignore the test

   505