1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "string.h"

     7

#include "table/strings.h"

     8

#include "command.h"

     9

#include "player.h"

    10

#include "gfx.h"

    11

#include "window.h"

    12

#include "gui.h"

    13

#include "economy.h"

    14

#include "network.h"

    15

#include "variables.h"

    16

#include "livery.h"

    17

    18

/** Change the player's face.

    19

 * @param tile unused

    20

 * @param p1 unused

    21

 * @param p2 face bitmasked

    22

 */

    23

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

    24

{

    25

	if (flags & DC_EXEC) {

    26

		GetPlayer(_current_player)->face = p2;

    27

		MarkWholeScreenDirty();

    28

	}

    29

	return 0;

    30

}

    31

    32

/** Change the player's company-colour

    33

 * @param tile unused

    34

 * @param p1 bitstuffed:

    35

 * p1 bits 0-7 scheme to set

    36

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

    37

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

    38

 */

    39

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

    40

{

    41

	Player *p, *pp;

    42

	byte colour;

    43

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

    44

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

    45

    46

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

    47

	colour = p2;

    48

    49

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

    50

    51

	p = GetPlayer(_current_player);

    52

    53

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

    54

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

    55

		FOR_ALL_PLAYERS(pp) {

    56

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

    57

		}

    58

	}

    59

    60

	if (flags & DC_EXEC) {

    61

		switch (state) {

    62

			case 0:

    63

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

    64

    65

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

    66

				 * original and cached player colours too. */

    67

				if (scheme == LS_DEFAULT) {

    68

					_player_colors[_current_player] = colour;

    69

					p->player_color = colour;

    70

				}

    71

				break;

    72

    73

			case 1:

    74

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

    75

				break;

    76

    77

			case 2:

    78

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

    79

    80

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

    81

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

    82

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

    83

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

    84

				 * colours will be used. */

    85

    86

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

    87

				if (colour != 0) {

    88

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

    89

					break;

    90

				}

    91

    92

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

    93

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

    94

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

    95

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

    96

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

    97

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

    98

						break;

    99

					}

   100

				}

   101

				break;

   102

   103

			default:

   104

				break;

   105

		}

   106

		MarkWholeScreenDirty();

   107

	}

   108

	return 0;

   109

}

   110

   111

/** Increase the loan of your company.

   112

 * @param tile unused

   113

 * @param p1 unused

   114

 * @param p2 when set, loans the maximum amount in one go (press CTRL)

   115

 */

   116

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

   117

{

   118

	Player *p;

   119

   120

	p = GetPlayer(_current_player);

   121

   122

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

   123

		SetDParam(0, _economy.max_loan);

   124

		return_cmd_error(STR_702B_MAXIMUM_PERMITTED_LOAN);

   125

	}

   126

   127

	if (flags & DC_EXEC) {

   128

		/* Loan the maximum amount or not? */

   129

		int32 loan = (p2) ? _economy.max_loan - p->current_loan : (IsHumanPlayer(_current_player) || _patches.ainew_active) ? 10000 : 50000;

   130

   131

		p->money64 += loan;

   132

		p->current_loan += loan;

   133

		UpdatePlayerMoney32(p);

   134

		InvalidatePlayerWindows(p);

   135

	}

   136

   137

	return 0;

   138

}

   139

   140

/** Decrease the loan of your company.

   141

 * @param tile unused

   142

 * @param p1 unused

   143

 * @param p2 when set, pays back the maximum loan permitting money (press CTRL)

   144

 */

   145

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

   146

{

   147

	Player *p;

   148

	int32 loan;

   149

   150

	p = GetPlayer(_current_player);

   151

   152

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

   153

   154

	loan = p->current_loan;

   155

   156

	/* p2 is true while CTRL is pressed (repay all possible loan, or max money you have)

   157

	 * Repay any loan in chunks of 10.000 pounds */

   158

	if (p2) {

   159

		loan = min(loan, p->player_money);

   160

		loan = max(loan, 10000);

   161

		loan -= loan % 10000;

   162

	} else {

   163

		loan = min(loan, (IsHumanPlayer(_current_player) || _patches.ainew_active) ? 10000 : 50000);

   164

	}

   165

   166

	if (p->player_money < loan) {

   167

		SetDParam(0, loan);

   168

		return_cmd_error(STR_702E_REQUIRED);

   169

	}

   170

   171

	if (flags & DC_EXEC) {

   172

		p->money64 -= loan;

   173

		p->current_loan -= loan;

   174

		UpdatePlayerMoney32(p);

   175

		InvalidatePlayerWindows(p);

   176

	}

   177

	return 0;

   178

}

   179

   180

/** Change the name of the company.

   181

 * @param tile unused

   182

 * @param p1 unused

   183

 * @param p2 unused

   184

 */

   185

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

   186

{

   187

	StringID str;

   188

	Player *p;

   189

   190

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

   191

   192

	str = AllocateNameUnique(_cmd_text, 4);

   193

	if (str == 0) return CMD_ERROR;

   194

   195

	if (flags & DC_EXEC) {

   196

		p = GetPlayer(_current_player);

   197

		DeleteName(p->name_1);

   198

		p->name_1 = str;

   199

		MarkWholeScreenDirty();

   200

	} else {

   201

		DeleteName(str);

   202

	}

   203

   204

	return 0;

   205

}

   206

   207

/** Change the name of the president.

   208

 * @param tile unused

   209

 * @param p1 unused

   210

 * @param p2 unused

   211

 */

   212

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

   213

{

   214

	StringID str;

   215

	Player *p;

   216

   217

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

   218

   219

	str = AllocateNameUnique(_cmd_text, 4);

   220

	if (str == 0) return CMD_ERROR;

   221

   222

	if (flags & DC_EXEC) {

   223

		p = GetPlayer(_current_player);

   224

		DeleteName(p->president_name_1);

   225

		p->president_name_1 = str;

   226

   227

		if (p->name_1 == STR_SV_UNNAMED) {

   228

			char buf[80];

   229

   230

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

   231

			_cmd_text = buf;

   232

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

   233

		}

   234

		MarkWholeScreenDirty();

   235

	} else {

   236

		DeleteName(str);

   237

	}

   238

   239

	return 0;

   240

}

   241

   242

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

   243

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

   244

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

   245

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

   246

 * @param tile unused

   247

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

   248

 * @param p2 unused

   249

 */

   250

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

   251

{

   252

	if (flags & DC_EXEC) {

   253

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

   254

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

   255

		InvalidateWindow(WC_STATUS_BAR, 0);

   256

		InvalidateWindow(WC_MAIN_TOOLBAR, 0);

   257

	}

   258

	return 0;

   259

}

   260

   261

/** Change the financial flow of your company.

   262

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

   263

 * build, you can cheat (to test).

   264

 * @param tile unused

   265

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

   266

 * @param p2 unused

   267

 */

   268

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

   269

{

   270

#ifndef _DEBUG

   271

	if (_networking) return CMD_ERROR;

   272

#endif

   273

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   274

	return (int32)p1;

   275

}

   276

   277

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

   278

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

   279

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

   280

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

   281

 * @param tile unused

   282

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

   283

 * @param p2 the player to transfer the money to

   284

 */

   285

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

   286

{

   287

	const Player *p = GetPlayer(_current_player);

   288

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

   289

   290

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   291

   292

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

   293

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

   294

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

   295

   296

	if (flags & DC_EXEC) {

   297

		/* Add money to player */

   298

		PlayerID old_cp = _current_player;

   299

		_current_player = p2;

   300

		SubtractMoneyFromPlayer(-amount);

   301

		_current_player = old_cp;

   302

	}

   303

   304

	/* Subtract money from local-player */

   305

	return amount;

   306

}

   307

   308

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

   309

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

   310

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

   311

 * what to do and does this correctly

   312

 * @param tile unused

   313

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

   314

 *           itself is changed. The new value is inside p2

   315

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

   316

 */

   317

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

   318

{

   319

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

   320

   321

	if (flags & DC_EXEC) {

   322

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

   323

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

   324

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

   325

		} else {

   326

			_opt_ptr->diff_level = p2;

   327

		}

   328

   329

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

   330

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

   331

		 * the new difficulty settings */

   332

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

   333

			ShowGameDifficulty();

   334

	}

   335

	return 0;

   336

}