1

/* $Id$ */

     2

     3

/** @file misc_cmd.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "functions.h"

     8

#include "string.h"

     9

#include "table/strings.h"

    10

#include "command.h"

    11

#include "player.h"

    12

#include "gfx.h"

    13

#include "window.h"

    14

#include "gui.h"

    15

#include "economy.h"

    16

#include "network/network.h"

    17

#include "variables.h"

    18

#include "livery.h"

    19

#include "player_face.h"

    20

    21

/** Change the player's face.

    22

 * @param tile unused

    23

 * @param p1 unused

    24

 * @param p2 face bitmasked

    25

 */

    26

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

    27

{

    28

	PlayerFace pf = (PlayerFace)p2;

    29

    30

	if (!IsValidPlayerFace(pf)) return CMD_ERROR;

    31

    32

	if (flags & DC_EXEC) {

    33

		GetPlayer(_current_player)->face = pf;

    34

		MarkWholeScreenDirty();

    35

	}

    36

	return 0;

    37

}

    38

    39

/** Change the player's company-colour

    40

 * @param tile unused

    41

 * @param p1 bitstuffed:

    42

 * p1 bits 0-7 scheme to set

    43

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

    44

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

    45

 */

    46

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

    47

{

    48

	Player *p, *pp;

    49

	byte colour;

    50

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

    51

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

    52

    53

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

    54

	colour = p2;

    55

    56

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

    57

    58

	p = GetPlayer(_current_player);

    59

    60

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

    61

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

    62

		FOR_ALL_PLAYERS(pp) {

    63

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

    64

		}

    65

	}

    66

    67

	if (flags & DC_EXEC) {

    68

		switch (state) {

    69

			case 0:

    70

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

    71

    72

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

    73

				 * original and cached player colours too. */

    74

				if (scheme == LS_DEFAULT) {

    75

					_player_colors[_current_player] = colour;

    76

					p->player_color = colour;

    77

				}

    78

				break;

    79

    80

			case 1:

    81

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

    82

				break;

    83

    84

			case 2:

    85

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

    86

    87

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

    88

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

    89

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

    90

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

    91

				 * colours will be used. */

    92

    93

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

    94

				if (colour != 0) {

    95

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

    96

					break;

    97

				}

    98

    99

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

   100

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

   101

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

   102

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

   103

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

   104

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

   105

						break;

   106

					}

   107

				}

   108

				break;

   109

   110

			default:

   111

				break;

   112

		}

   113

		MarkWholeScreenDirty();

   114

	}

   115

	return 0;

   116

}

   117

   118

/** Increase the loan of your company.

   119

 * @param tile unused

   120

 * @param p1 amount to increase the loan with, multitude of LOAN_INTERVAL. Only used when p2 == 2.

   121

 * @param p2 when 0: loans LOAN_INTERVAL

   122

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

   123

 *           when 2: loans the amount specified in p1

   124

 */

   125

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

   126

{

   127

	Player *p = GetPlayer(_current_player);

   128

   129

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

   130

		SetDParam(0, _economy.max_loan);

   131

		return_cmd_error(STR_702B_MAXIMUM_PERMITTED_LOAN);

   132

	}

   133

   134

	/* Invalid method */

   135

	if (p2 >= 3) return CMD_ERROR;

   136

   137

	/* Invalid amount to increase the loan with */

   138

	if (p2 == 2 && (((int32)p1 < LOAN_INTERVAL) || p->current_loan + (int32)p1 > _economy.max_loan || (p1 % LOAN_INTERVAL) != 0)) return CMD_ERROR;

   139

   140

	if (flags & DC_EXEC) {

   141

		int32 loan;

   142

		/* Amount to loan */

   143

		switch (p2) {

   144

			default: NOT_REACHED();

   145

			case 0:

   146

				loan = LOAN_INTERVAL;

   147

				break;

   148

			case 1:

   149

				loan = _economy.max_loan - p->current_loan;

   150

				break;

   151

			case 2:

   152

				loan = p1;

   153

				break;

   154

		}

   155

   156

		p->money64 += loan;

   157

		p->current_loan += loan;

   158

		UpdatePlayerMoney32(p);

   159

		InvalidatePlayerWindows(p);

   160

	}

   161

   162

	return 0;

   163

}

   164

   165

/** Decrease the loan of your company.

   166

 * @param tile unused

   167

 * @param p1 amount to decrease the loan with, multitude of LOAN_INTERVAL. Only used when p2 == 2.

   168

 * @param p2 when 0: pays back LOAN_INTERVAL

   169

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

   170

 *           when 2: pays back the amount specified in p1

   171

 */

   172

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

   173

{

   174

	Player *p = GetPlayer(_current_player);

   175

   176

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

   177

   178

	int32 loan;

   179

	switch (p2) {

   180

		default: return CMD_ERROR; // Invalid method

   181

		case 0:

   182

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

   183

			break;

   184

		case 1:

   185

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

   186

			loan -= loan % LOAN_INTERVAL;

   187

			break;

   188

		case 2:

   189

			if ((p1 % LOAN_INTERVAL != 0) || ((int32)p1 < LOAN_INTERVAL)) return CMD_ERROR; // Invalid amount to loan

   190

			loan = p1;

   191

			break;

   192

	}

   193

   194

	if (p->player_money < loan) {

   195

		SetDParam(0, loan);

   196

		return_cmd_error(STR_702E_REQUIRED);

   197

	}

   198

   199

	if (flags & DC_EXEC) {

   200

		p->money64 -= loan;

   201

		p->current_loan -= loan;

   202

		UpdatePlayerMoney32(p);

   203

		InvalidatePlayerWindows(p);

   204

	}

   205

	return 0;

   206

}

   207

   208

/** Change the name of the company.

   209

 * @param tile unused

   210

 * @param p1 unused

   211

 * @param p2 unused

   212

 */

   213

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

   214

{

   215

	StringID str;

   216

	Player *p;

   217

   218

	if (_cmd_text[0] == '\0') return CMD_ERROR;

   219

   220

	str = AllocateNameUnique(_cmd_text, 4);

   221

	if (str == 0) return CMD_ERROR;

   222

   223

	if (flags & DC_EXEC) {

   224

		p = GetPlayer(_current_player);

   225

		DeleteName(p->name_1);

   226

		p->name_1 = str;

   227

		MarkWholeScreenDirty();

   228

	} else {

   229

		DeleteName(str);

   230

	}

   231

   232

	return 0;

   233

}

   234

   235

/** Change the name of the president.

   236

 * @param tile unused

   237

 * @param p1 unused

   238

 * @param p2 unused

   239

 */

   240

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

   241

{

   242

	StringID str;

   243

	Player *p;

   244

   245

	if (_cmd_text[0] == '\0') return CMD_ERROR;

   246

   247

	str = AllocateNameUnique(_cmd_text, 4);

   248

	if (str == 0) return CMD_ERROR;

   249

   250

	if (flags & DC_EXEC) {

   251

		p = GetPlayer(_current_player);

   252

		DeleteName(p->president_name_1);

   253

		p->president_name_1 = str;

   254

   255

		if (p->name_1 == STR_SV_UNNAMED) {

   256

			char buf[80];

   257

   258

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

   259

			_cmd_text = buf;

   260

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

   261

		}

   262

		MarkWholeScreenDirty();

   263

	} else {

   264

		DeleteName(str);

   265

	}

   266

   267

	return 0;

   268

}

   269

   270

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

   271

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

   272

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

   273

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

   274

 * @param tile unused

   275

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

   276

 * @param p2 unused

   277

 */

   278

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

   279

{

   280

	if (flags & DC_EXEC) {

   281

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

   282

		if (_pause_game == (byte)-1) _pause_game = 0;

   283

		InvalidateWindow(WC_STATUS_BAR, 0);

   284

		InvalidateWindow(WC_MAIN_TOOLBAR, 0);

   285

	}

   286

	return 0;

   287

}

   288

   289

/** Change the financial flow of your company.

   290

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

   291

 * build, you can cheat (to test).

   292

 * @param tile unused

   293

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

   294

 * @param p2 unused

   295

 */

   296

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

   297

{

   298

#ifndef _DEBUG

   299

	if (_networking) return CMD_ERROR;

   300

#endif

   301

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   302

	return -(int32)p1;

   303

}

   304

   305

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

   306

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

   307

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

   308

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

   309

 * @param tile unused

   310

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

   311

 * @param p2 the player to transfer the money to

   312

 */

   313

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

   314

{

   315

	const Player *p = GetPlayer(_current_player);

   316

	int32 amount = min((int32)p1, 20000000);

   317

   318

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   319

   320

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

   321

	if (p->money64 - p->current_loan < amount || amount <= 0) return CMD_ERROR;

   322

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

   323

   324

	if (flags & DC_EXEC) {

   325

		/* Add money to player */

   326

		PlayerID old_cp = _current_player;

   327

		_current_player = (PlayerID)p2;

   328

		SubtractMoneyFromPlayer(-amount);

   329

		_current_player = old_cp;

   330

	}

   331

   332

	/* Subtract money from local-player */

   333

	return amount;

   334

}

   335

   336

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

   337

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

   338

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

   339

 * what to do and does this correctly

   340

 * @param tile unused

   341

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

   342

 *           itself is changed. The new value is inside p2

   343

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

   344

 */

   345

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

   346

{

   347

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

   348

   349

	if (flags & DC_EXEC) {

   350

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

   351

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

   352

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

   353

		} else {

   354

			_opt_ptr->diff_level = p2;

   355

		}

   356

   357

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

   358

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

   359

		 * the new difficulty settings */

   360

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

   361

			ShowGameDifficulty();

   362

	}

   363

	return 0;

   364

}