1

/* $Id$ */

     2

     3

/** @file misc_cmd.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/strings.h"

     8

#include "command_func.h"

     9

#include "economy_func.h"

    10

#include "player.h"

    11

#include "gui.h"

    12

#include "window_func.h"

    13

#include "textbuf_gui.h"

    14

#include "network/network.h"

    15

#include "variables.h"

    16

#include "livery.h"

    17

#include "player_face.h"

    18

#include "strings_func.h"

    19

#include "gfx_func.h"

    20

#include "functions.h"

    21

#include "vehicle_func.h"

    23

    24

/** Change the player's face.

    25

 * @param tile unused

    26

 * @param flags operation to perform

    27

 * @param p1 unused

    28

 * @param p2 face bitmasked

    29

 */

    30

CommandCost CmdSetPlayerFace(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

    31

{

    32

	PlayerFace pf = (PlayerFace)p2;

    33

    34

	if (!IsValidPlayerFace(pf)) return CMD_ERROR;

    35

    36

	if (flags & DC_EXEC) {

    37

		GetPlayer(_current_player)->face = pf;

    38

		MarkWholeScreenDirty();

    39

	}

    40

	return CommandCost();

    41

}

    42

    43

/** Change the player's company-colour

    44

 * @param tile unused

    45

 * @param flags operation to perform

    46

 * @param p1 bitstuffed:

    47

 * p1 bits 0-7 scheme to set

    48

 * p1 bits 8-9 set in use state or first/second colour

    49

 * @param p2 new colour for vehicles, property, etc.

    50

 */

    51

CommandCost CmdSetPlayerColor(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

    52

{

    53

	Player *p, *pp;

    54

	byte colour;

    55

	LiveryScheme scheme = (LiveryScheme)GB(p1, 0, 8);

    56

	byte state = GB(p1, 8, 2);

    57

    58

	if (p2 >= 16) return CMD_ERROR; // max 16 colours

    59

	colour = p2;

    60

    61

	if (scheme >= LS_END || state >= 3) return CMD_ERROR;

    62

    63

	p = GetPlayer(_current_player);

    64

    65

	/* Ensure no two companies have the same primary colour */

    66

	if (scheme == LS_DEFAULT && state == 0) {

    67

		FOR_ALL_PLAYERS(pp) {

    68

			if (pp->is_active && pp != p && pp->player_color == colour) return CMD_ERROR;

    69

		}

    70

	}

    71

    72

	if (flags & DC_EXEC) {

    73

		switch (state) {

    74

			case 0:

    75

				p->livery[scheme].colour1 = colour;

    76

    77

				/* If setting the first colour of the default scheme, adjust the

    78

				 * original and cached player colours too. */

    79

				if (scheme == LS_DEFAULT) {

    80

					_player_colors[_current_player] = colour;

    81

					p->player_color = colour;

    82

				}

    83

				break;

    84

    85

			case 1:

    86

				p->livery[scheme].colour2 = colour;

    87

				break;

    88

    89

			case 2:

    90

				p->livery[scheme].in_use = colour != 0;

    91

    92

				/* Now handle setting the default scheme's in_use flag.

    93

				 * This is different to the other schemes, as it signifies if any

    94

				 * scheme is active at all. If this flag is not set, then no

    95

				 * processing of vehicle types occurs at all, and only the default

    96

				 * colours will be used. */

    97

    98

				/* If enabling a scheme, set the default scheme to be in use too */

    99

				if (colour != 0) {

   100

					p->livery[LS_DEFAULT].in_use = true;

   101

					break;

   102

				}

   103

   104

				/* Else loop through all schemes to see if any are left enabled.

   105

				 * If not, disable the default scheme too. */

   106

				p->livery[LS_DEFAULT].in_use = false;

   107

				for (scheme = LS_DEFAULT; scheme < LS_END; scheme++) {

   108

					if (p->livery[scheme].in_use) {

   109

						p->livery[LS_DEFAULT].in_use = true;

   110

						break;

   111

					}

   112

				}

   113

				break;

   114

   115

			default:

   116

				break;

   117

		}

   118

		ResetVehicleColorMap();

   119

		MarkWholeScreenDirty();

   120

	}

   121

	return CommandCost();

   122

}

   123

   124

/** Increase the loan of your company.

   125

 * @param tile unused

   126

 * @param flags operation to perform

   127

 * @param p1 unused

   128

 * @param p2 when 0: loans LOAN_INTERVAL

   129

 *           when 1: loans the maximum loan permitting money (press CTRL),

   130

 */

   131

CommandCost CmdIncreaseLoan(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   132

{

   133

	Player *p = GetPlayer(_current_player);

   134

   135

	if (p->current_loan >= _economy.max_loan) {

   136

		SetDParam(0, _economy.max_loan);

   137

		return_cmd_error(STR_702B_MAXIMUM_PERMITTED_LOAN);

   138

	}

   139

   140

	Money loan;

   141

	switch (p2) {

   142

		default: return CMD_ERROR; // Invalid method

   143

		case 0: // Take some extra loan

   144

			loan = (IsHumanPlayer(_current_player) || _patches.ainew_active) ? LOAN_INTERVAL : LOAN_INTERVAL_OLD_AI;

   145

			break;

   146

		case 1: // Take a loan as big as possible

   147

			loan = _economy.max_loan - p->current_loan;

   148

			break;

   149

	}

   150

   151

	/* Overflow protection */

   152

	if (p->player_money + p->current_loan + loan < p->player_money) return CMD_ERROR;

   153

   154

	if (flags & DC_EXEC) {

   155

		p->player_money += loan;

   156

		p->current_loan += loan;

   157

		InvalidatePlayerWindows(p);

   158

	}

   159

   160

	return CommandCost();

   161

}

   162

   163

/** Decrease the loan of your company.

   164

 * @param tile unused

   165

 * @param flags operation to perform

   166

 * @param p1 unused

   167

 * @param p2 when 0: pays back LOAN_INTERVAL

   168

 *           when 1: pays back the maximum loan permitting money (press CTRL),

   169

 */

   170

CommandCost CmdDecreaseLoan(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   171

{

   172

	Player *p = GetPlayer(_current_player);

   173

   174

	if (p->current_loan == 0) return_cmd_error(STR_702D_LOAN_ALREADY_REPAYED);

   175

   176

	Money loan;

   177

	switch (p2) {

   178

		default: return CMD_ERROR; // Invalid method

   179

		case 0: // Pay back one step

   180

			loan = min(p->current_loan, (Money)(IsHumanPlayer(_current_player) || _patches.ainew_active) ? LOAN_INTERVAL : LOAN_INTERVAL_OLD_AI);

   181

			break;

   182

		case 1: // Pay back as much as possible

   183

			loan = max(min(p->current_loan, p->player_money), (Money)LOAN_INTERVAL);

   184

			loan -= loan % LOAN_INTERVAL;

   185

			break;

   186

	}

   187

   188

	if (p->player_money < loan) {

   189

		SetDParam(0, loan);

   190

		return_cmd_error(STR_702E_REQUIRED);

   191

	}

   192

   193

	if (flags & DC_EXEC) {

   194

		p->player_money -= loan;

   195

		p->current_loan -= loan;

   196

		InvalidatePlayerWindows(p);

   197

	}

   198

	return CommandCost();

   199

}

   200

   201

static bool IsUniqueCompanyName(const char *name)

   202

{

   203

	const Player *p;

   204

	char buf[512];

   205

   206

	FOR_ALL_PLAYERS(p) {

   207

		if (!p->is_active) continue;

   208

		SetDParam(0, p->index);

   209

		GetString(buf, STR_COMPANY_NAME, lastof(buf));

   210

		if (strcmp(buf, name) == 0) return false;

   211

	}

   212

   213

	return true;

   214

}

   215

   216

/** Change the name of the company.

   217

 * @param tile unused

   218

 * @param flags operation to perform

   219

 * @param p1 unused

   220

 * @param p2 unused

   221

 */

   222

CommandCost CmdChangeCompanyName(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   223

{

   224

	StringID str;

   225

	Player *p;

   226

   227

	if (StrEmpty(_cmd_text)) return CMD_ERROR;

   228

   229

	if (!IsUniqueCompanyName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE);

   230

   231

	str = AllocateName(_cmd_text, 4);

   232

	if (str == 0) return CMD_ERROR;

   233

   234

	if (flags & DC_EXEC) {

   235

		p = GetPlayer(_current_player);

   236

		DeleteName(p->name_1);

   237

		p->name_1 = str;

   238

		MarkWholeScreenDirty();

   239

	} else {

   240

		DeleteName(str);

   241

	}

   242

   243

	return CommandCost();

   244

}

   245

   246

static bool IsUniquePresidentName(const char *name)

   247

{

   248

	const Player *p;

   249

	char buf[512];

   250

   251

	FOR_ALL_PLAYERS(p) {

   252

		if (!p->is_active) continue;

   253

		SetDParam(0, p->index);

   254

		GetString(buf, STR_PLAYER_NAME, lastof(buf));

   255

		if (strcmp(buf, name) == 0) return false;

   256

	}

   257

   258

	return true;

   259

}

   260

   261

/** Change the name of the president.

   262

 * @param tile unused

   263

 * @param flags operation to perform

   264

 * @param p1 unused

   265

 * @param p2 unused

   266

 */

   267

CommandCost CmdChangePresidentName(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   268

{

   269

	StringID str;

   270

	Player *p;

   271

   272

	if (StrEmpty(_cmd_text)) return CMD_ERROR;

   273

   274

	if (!IsUniquePresidentName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE);

   275

   276

	str = AllocateName(_cmd_text, 4);

   277

	if (str == 0) return CMD_ERROR;

   278

   279

	if (flags & DC_EXEC) {

   280

		p = GetPlayer(_current_player);

   281

		DeleteName(p->president_name_1);

   282

		p->president_name_1 = str;

   283

   284

		if (p->name_1 == STR_SV_UNNAMED) {

   285

			char buf[80];

   286

   287

			snprintf(buf, lengthof(buf), "%s Transport", _cmd_text);

   288

			_cmd_text = buf;

   289

			DoCommand(0, 0, 0, DC_EXEC, CMD_CHANGE_COMPANY_NAME);

   290

		}

   291

		MarkWholeScreenDirty();

   292

	} else {

   293

		DeleteName(str);

   294

	}

   295

   296

	return CommandCost();

   297

}

   298

   299

/**

   300

 * In case of an unsafe unpause, we want the

   301

 * user to confirm that it might crash.

   302

 * @param w         unused

   303

 * @param confirmed whether the user confirms his/her action

   304

 */

   305

static void AskUnsafeUnpauseCallback(Window *w, bool confirmed)

   306

{

   307

	DoCommandP(0, confirmed ? 0 : 1, 0, NULL, CMD_PAUSE);

   308

}

   309

   310

/** Pause/Unpause the game (server-only).

   311

 * Increase or decrease the pause counter. If the counter is zero,

   312

 * the game is unpaused. A counter is used instead of a boolean value

   313

 * to have more control over the game when saving/loading, etc.

   314

 * @param tile unused

   315

 * @param flags operation to perform

   316

 * @param p1 0 = decrease pause counter; 1 = increase pause counter

   317

 * @param p2 unused

   318

 */

   319

CommandCost CmdPause(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   320

{

   321

	if (flags & DC_EXEC) {

   322

		_pause_game += (p1 == 0) ? -1 : 1;

   323

   324

		switch (_pause_game) {

   325

			case (byte)-4:

   326

			case (byte)-1:

   327

				_pause_game = 0;

   328

				break;

   329

			case (byte)-3:

   330

				ShowQuery(

   331

					STR_NEWGRF_UNPAUSE_WARNING_TITLE,

   332

					STR_NEWGRF_UNPAUSE_WARNING,

   333

					NULL,

   334

					AskUnsafeUnpauseCallback

   335

				);

   336

				break;

   337

   338

			default: break;

   339

		}

   340

   341

		InvalidateWindow(WC_STATUS_BAR, 0);

   342

		InvalidateWindow(WC_MAIN_TOOLBAR, 0);

   343

	}

   344

	return CommandCost();

   345

}

   346

   347

/** Change the financial flow of your company.

   348

 * This is normally only enabled in offline mode, but if there is a debug

   349

 * build, you can cheat (to test).

   350

 * @param tile unused

   351

 * @param flags operation to perform

   352

 * @param p1 the amount of money to receive (if negative), or spend (if positive)

   353

 * @param p2 unused

   354

 */

   355

CommandCost CmdMoneyCheat(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   356

{

   357

#ifndef _DEBUG

   358

	if (_networking) return CMD_ERROR;

   359

#endif

   360

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   361

	return CommandCost(-(Money)p1);

   362

}

   363

   364

/** Transfer funds (money) from one player to another.

   365

 * To prevent abuse in multiplayer games you can only send money to other

   366

 * players if you have paid off your loan (either explicitely, or implicitely

   367

 * given the fact that you have more money than loan).

   368

 * @param tile unused

   369

 * @param flags operation to perform

   370

 * @param p1 the amount of money to transfer; max 20.000.000

   371

 * @param p2 the player to transfer the money to

   372

 */

   373

CommandCost CmdGiveMoney(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   374

{

   375

	if (!_patches.give_money) return CMD_ERROR;

   376

   377

	const Player *p = GetPlayer(_current_player);

   378

	CommandCost amount(min((Money)p1, (Money)20000000LL));

   379

   380

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   381

   382

	/* You can only transfer funds that is in excess of your loan */

   383

	if (p->player_money - p->current_loan < amount.GetCost() || amount.GetCost() <= 0) return CMD_ERROR;

   384

	if (!_networking || !IsValidPlayer((PlayerID)p2)) return CMD_ERROR;

   385

   386

	if (flags & DC_EXEC) {

   387

		/* Add money to player */

   388

		PlayerID old_cp = _current_player;

   389

		_current_player = (PlayerID)p2;

   390

		SubtractMoneyFromPlayer(CommandCost(-amount.GetCost()));

   391

		_current_player = old_cp;

   392

	}

   393

   394

	/* Subtract money from local-player */

   395

	return amount;

   396

}

   397

   398

/** Change difficulty level/settings (server-only).

   399

 * We cannot really check for valid values of p2 (too much work mostly); stored

   400

 * in file 'settings_gui.c' _game_setting_info[]; we'll just trust the server it knows

   401

 * what to do and does this correctly

   402

 * @param tile unused

   403

 * @param flags operation to perform

   404

 * @param p1 the difficulty setting being changed. If it is -1, the difficulty level

   405

 *           itself is changed. The new value is inside p2

   406

 * @param p2 new value for a difficulty setting or difficulty level

   407

 */

   408

CommandCost CmdChangeDifficultyLevel(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   409

{

   410

	if (p1 != (uint32)-1L && ((int32)p1 >= GAME_DIFFICULTY_NUM || (int32)p1 < 0)) return CMD_ERROR;

   411

   412

	if (flags & DC_EXEC) {

   413

		if (p1 != (uint32)-1L) {

   414

			((GDType*)&_opt_ptr->diff)[p1] = p2;

   415

			_opt_ptr->diff_level = 3; // custom difficulty level

   416

		} else {

   417

			_opt_ptr->diff_level = p2;

   418

		}

   419

   420

		/* If we are a network-client, update the difficult setting (if it is open).

   421

		 * Use this instead of just dirtying the window because we need to load in

   422

		 * the new difficulty settings */

   423

		if (_networking && !_network_server && FindWindowById(WC_GAME_OPTIONS, 0) != NULL)

   424

			ShowGameDifficulty();

   425

	}

   426

	return CommandCost();

   427

}