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/network.h"

    15

#include "variables.h"

    16

#include "livery.h"

    18

    19

/** Change the player's face.

    20

 * @param tile unused

    21

 * @param p1 unused

    22

 * @param p2 face bitmasked

    23

 */

    24

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

    25

{

    30

	if (flags & DC_EXEC) {

    32

		MarkWholeScreenDirty();

    33

	}

    34

	return 0;

    35

}

    36

    37

/** Change the player's company-colour

    38

 * @param tile unused

    39

 * @param p1 bitstuffed:

    40

 * p1 bits 0-7 scheme to set

    41

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

    42

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

    43

 */

    44

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

    45

{

    46

	Player *p, *pp;

    47

	byte colour;

    48

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

    49

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

    50

    51

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

    52

	colour = p2;

    53

    54

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

    55

    56

	p = GetPlayer(_current_player);

    57

    58

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

    59

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

    60

		FOR_ALL_PLAYERS(pp) {

    61

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

    62

		}

    63

	}

    64

    65

	if (flags & DC_EXEC) {

    66

		switch (state) {

    67

			case 0:

    68

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

    69

    70

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

    71

				 * original and cached player colours too. */

    72

				if (scheme == LS_DEFAULT) {

    73

					_player_colors[_current_player] = colour;

    74

					p->player_color = colour;

    75

				}

    76

				break;

    77

    78

			case 1:

    79

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

    80

				break;

    81

    82

			case 2:

    83

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

    84

    85

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

    86

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

    87

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

    88

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

    89

				 * colours will be used. */

    90

    91

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

    92

				if (colour != 0) {

    93

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

    94

					break;

    95

				}

    96

    97

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

    98

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

    99

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

   100

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

   101

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

   102

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

   103

						break;

   104

					}

   105

				}

   106

				break;

   107

   108

			default:

   109

				break;

   110

		}

   111

		MarkWholeScreenDirty();

   112

	}

   113

	return 0;

   114

}

   115

   116

/** Increase the loan of your company.

   117

 * @param tile unused

   118

 * @param p1 unused

   119

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

   120

 */

   121

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

   122

{

   123

	Player *p;

   124

   125

	p = GetPlayer(_current_player);

   126

   127

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

   128

		SetDParam(0, _economy.max_loan);

   129

		return_cmd_error(STR_702B_MAXIMUM_PERMITTED_LOAN);

   130

	}

   131

   132

	if (flags & DC_EXEC) {

   133

		/* Loan the maximum amount or not? */

   134

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

   135

   136

		p->money64 += loan;

   137

		p->current_loan += loan;

   138

		UpdatePlayerMoney32(p);

   139

		InvalidatePlayerWindows(p);

   140

	}

   141

   142

	return 0;

   143

}

   144

   145

/** Decrease the loan of your company.

   146

 * @param tile unused

   147

 * @param p1 unused

   148

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

   149

 */

   150

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

   151

{

   152

	Player *p;

   153

	int32 loan;

   154

   155

	p = GetPlayer(_current_player);

   156

   157

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

   158

   159

	loan = p->current_loan;

   160

   161

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

   162

	 * Repay any loan in chunks of 10.000 pounds */

   163

	if (p2) {

   164

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

   165

		loan = max(loan, 10000);

   166

		loan -= loan % 10000;

   167

	} else {

   168

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

   169

	}

   170

   171

	if (p->player_money < loan) {

   172

		SetDParam(0, loan);

   173

		return_cmd_error(STR_702E_REQUIRED);

   174

	}

   175

   176

	if (flags & DC_EXEC) {

   177

		p->money64 -= loan;

   178

		p->current_loan -= loan;

   179

		UpdatePlayerMoney32(p);

   180

		InvalidatePlayerWindows(p);

   181

	}

   182

	return 0;

   183

}

   184

   185

/** Change the name of the company.

   186

 * @param tile unused

   187

 * @param p1 unused

   188

 * @param p2 unused

   189

 */

   190

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

   191

{

   192

	StringID str;

   193

	Player *p;

   194

   195

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

   196

   197

	str = AllocateNameUnique(_cmd_text, 4);

   198

	if (str == 0) return CMD_ERROR;

   199

   200

	if (flags & DC_EXEC) {

   201

		p = GetPlayer(_current_player);

   202

		DeleteName(p->name_1);

   203

		p->name_1 = str;

   204

		MarkWholeScreenDirty();

   205

	} else {

   206

		DeleteName(str);

   207

	}

   208

   209

	return 0;

   210

}

   211

   212

/** Change the name of the president.

   213

 * @param tile unused

   214

 * @param p1 unused

   215

 * @param p2 unused

   216

 */

   217

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

   218

{

   219

	StringID str;

   220

	Player *p;

   221

   222

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

   223

   224

	str = AllocateNameUnique(_cmd_text, 4);

   225

	if (str == 0) return CMD_ERROR;

   226

   227

	if (flags & DC_EXEC) {

   228

		p = GetPlayer(_current_player);

   229

		DeleteName(p->president_name_1);

   230

		p->president_name_1 = str;

   231

   232

		if (p->name_1 == STR_SV_UNNAMED) {

   233

			char buf[80];

   234

   235

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

   236

			_cmd_text = buf;

   237

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

   238

		}

   239

		MarkWholeScreenDirty();

   240

	} else {

   241

		DeleteName(str);

   242

	}

   243

   244

	return 0;

   245

}

   246

   247

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

   248

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

   249

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

   250

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

   251

 * @param tile unused

   252

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

   253

 * @param p2 unused

   254

 */

   255

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

   256

{

   257

	if (flags & DC_EXEC) {

   258

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

   259

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

   260

		InvalidateWindow(WC_STATUS_BAR, 0);

   261

		InvalidateWindow(WC_MAIN_TOOLBAR, 0);

   262

	}

   263

	return 0;

   264

}

   265

   266

/** Change the financial flow of your company.

   267

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

   268

 * build, you can cheat (to test).

   269

 * @param tile unused

   270

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

   271

 * @param p2 unused

   272

 */

   273

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

   274

{

   275

#ifndef _DEBUG

   276

	if (_networking) return CMD_ERROR;

   277

#endif

   278

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   279

	return -(int32)p1;

   280

}

   281

   282

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

   283

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

   284

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

   285

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

   286

 * @param tile unused

   287

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

   288

 * @param p2 the player to transfer the money to

   289

 */

   290

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

   291

{

   292

	const Player *p = GetPlayer(_current_player);

   293

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

   294

   295

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   296

   297

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

   298

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

   299

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

   300

   301

	if (flags & DC_EXEC) {

   302

		/* Add money to player */

   303

		PlayerID old_cp = _current_player;

   304

		_current_player = (PlayerID)p2;

   305

		SubtractMoneyFromPlayer(-amount);

   306

		_current_player = old_cp;

   307

	}

   308

   309

	/* Subtract money from local-player */

   310

	return amount;

   311

}

   312

   313

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

   314

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

   315

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

   316

 * what to do and does this correctly

   317

 * @param tile unused

   318

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

   319

 *           itself is changed. The new value is inside p2

   320

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

   321

 */

   322

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

   323

{

   324

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

   325

   326

	if (flags & DC_EXEC) {

   327

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

   328

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

   329

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

   330

		} else {

   331

			_opt_ptr->diff_level = p2;

   332

		}

   333

   334

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

   335

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

   336

		 * the new difficulty settings */

   337

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

   338

			ShowGameDifficulty();

   339

	}

   340

	return 0;

   341

}