1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "string.h"

     4

#include "table/strings.h"

     5

#include "command.h"

     6

#include "player.h"

     7

#include "gfx.h"

     8

#include "window.h"

     9

#include "gui.h"

    10

#include "saveload.h"

    11

#include "economy.h"

    12

#include "network.h"

    13

    14

/** Change the player's face.

    15

 * @param x,y unused

    16

 * @param p1 unused

    17

 * @param p2 face bitmasked

    18

 */

    19

int32 CmdSetPlayerFace(int x, int y, uint32 flags, uint32 p1, uint32 p2)

    20

{

    21

	if (flags & DC_EXEC) {

    22

		GetPlayer(_current_player)->face = p2;

    23

		MarkWholeScreenDirty();

    24

	}

    25

	return 0;

    26

}

    27

    28

/** Change the player's company-colour

    29

 * @param x,y unused

    30

 * @param p1 unused

    31

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

    32

 */

    33

int32 CmdSetPlayerColor(int x, int y, uint32 flags, uint32 p1, uint32 p2)

    34

{

    35

	Player *p, *pp;

    39

    40

	p = GetPlayer(_current_player);

    41

    42

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

    43

	FOR_ALL_PLAYERS(pp) {

    45

			return CMD_ERROR;

    46

	}

    47

    48

	if (flags & DC_EXEC) {

    51

		MarkWholeScreenDirty();

    52

	}

    53

	return 0;

    54

}

    55

    56

/** Increase the loan of your company.

    57

 * @param x,y unused

    58

 * @param p1 unused

    59

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

    60

 */

    61

int32 CmdIncreaseLoan(int x, int y, uint32 flags, uint32 p1, uint32 p2)

    62

{

    63

	Player *p;

    64

    65

	p = GetPlayer(_current_player);

    66

    67

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

    68

		SetDParam(0, _economy.max_loan);

    69

		return_cmd_error(STR_702B_MAXIMUM_PERMITTED_LOAN);

    70

	}

    71

    72

	if (flags & DC_EXEC) {

    73

		/* Loan the maximum amount or not? */

    74

		int32 loan = (p2) ? _economy.max_loan - p->current_loan : IS_HUMAN_PLAYER(_current_player) ? 10000 : 50000;

    75

    76

		p->money64 += loan;

    77

		p->current_loan += loan;

    78

		UpdatePlayerMoney32(p);

    79

		InvalidatePlayerWindows(p);

    80

	}

    81

    82

	return 0;

    83

}

    84

    85

/** Decrease the loan of your company.

    86

 * @param x,y unused

    87

 * @param p1 unused

    88

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

    89

 */

    90

int32 CmdDecreaseLoan(int x, int y, uint32 flags, uint32 p1, uint32 p2)

    91

{

    92

	Player *p;

    93

	int32 loan;

    94

    95

	p = GetPlayer(_current_player);

    96

    97

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

    98

    99

	loan = p->current_loan;

   100

   101

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

   102

	 * Repay any loan in chunks of 10.000 pounds */

   103

	if (p2) {

   104

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

   105

		loan = max(loan, 10000);

   106

		loan -= loan % 10000;

   107

	} else {

   108

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

   109

	}

   110

   111

	if (p->player_money < loan) {

   112

		SetDParam(0, loan);

   113

		return_cmd_error(STR_702E_REQUIRED);

   114

	}

   115

   116

	if (flags & DC_EXEC) {

   117

		p->money64 -= loan;

   118

		p->current_loan -= loan;

   119

		UpdatePlayerMoney32(p);

   120

		InvalidatePlayerWindows(p);

   121

	}

   122

	return 0;

   123

}

   124

   125

/** Change the name of the company.

   126

 * @param x,y unused

   127

 * @param p1 unused

   128

 * @param p2 unused

   129

 */

   130

int32 CmdChangeCompanyName(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   131

{

   132

	StringID str;

   133

	Player *p;

   134

   135

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

   136

   137

	str = AllocateNameUnique(_cmd_text, 4);

   138

	if (str == 0) return CMD_ERROR;

   139

   140

	if (flags & DC_EXEC) {

   141

		p = DEREF_PLAYER(_current_player);

   142

		DeleteName(p->name_1);

   143

		p->name_1 = str;

   144

		MarkWholeScreenDirty();

   145

	} else

   146

		DeleteName(str);

   147

   148

	return 0;

   149

}

   150

   151

/** Change the name of the president.

   152

 * @param x,y unused

   153

 * @param p1 unused

   154

 * @param p2 unused

   155

 */

   156

int32 CmdChangePresidentName(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   157

{

   158

	StringID str;

   159

	Player *p;

   160

   161

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

   162

   163

	str = AllocateNameUnique(_cmd_text, 4);

   164

	if (str == 0) return CMD_ERROR;

   165

   166

	if (flags & DC_EXEC) {

   167

		p = DEREF_PLAYER(_current_player);

   168

		DeleteName(p->president_name_1);

   169

		p->president_name_1 = str;

   170

   171

		if (p->name_1 == STR_SV_UNNAMED) {

   172

			char buf[80];

   173

   174

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

   175

			_cmd_text = buf;

   176

			DoCommandByTile(0, 0, 0, DC_EXEC, CMD_CHANGE_COMPANY_NAME);

   177

		}

   178

		MarkWholeScreenDirty();

   179

	} else

   180

		DeleteName(str);

   181

   182

	return 0;

   183

}

   184

   185

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

   186

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

   187

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

   188

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

   189

 * @param x,y unused

   190

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

   191

 * @param p2 unused

   192

 */

   193

int32 CmdPause(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   194

{

   195

	if (flags & DC_EXEC) {

   196

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

   197

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

   198

		InvalidateWindow(WC_STATUS_BAR, 0);

   199

		InvalidateWindow(WC_MAIN_TOOLBAR, 0);

   200

	}

   201

	return 0;

   202

}

   203

   204

/** Change the financial flow of your company.

   205

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

   206

 * build, you can cheat (to test).

   207

 * @param x,y unused

   208

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

   209

 * @param p2 unused

   210

 */

   211

int32 CmdMoneyCheat(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   212

{

   213

#ifndef _DEBUG

   214

	if (_networking) return CMD_ERROR;

   215

#endif

   216

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   217

	return (int32)p1;

   218

}

   219

   220

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

   221

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

   222

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

   223

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

   224

 * @param x,y unused

   225

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

   226

 * @param p2 the player to transfer the money to

   227

 */

   228

int32 CmdGiveMoney(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   229

{

   230

	const Player *p = DEREF_PLAYER(_current_player);

   231

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

   232

   233

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   234

   235

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

   236

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

   237

	if (!_networking || p2 >= MAX_PLAYERS) return CMD_ERROR;

   238

   239

	if (flags & DC_EXEC) {

   240

		/* Add money to player */

   241

		PlayerID old_cp = _current_player;

   242

		_current_player = p2;

   243

		SubtractMoneyFromPlayer(-amount);

   244

		_current_player = old_cp;

   245

	}

   246

   247

	/* Subtract money from local-player */

   248

	return amount;

   249

}

   250

   251

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

   252

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

   253

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

   254

 * what to do and does this correctly

   255

 * @param x,y unused

   256

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

   257

 *           itself is changed. The new value is inside p2

   258

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

   259

 */

   260

int32 CmdChangeDifficultyLevel(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   261

{

   262

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

   263

   264

	if (flags & DC_EXEC) {

   265

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

   266

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

   267

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

   268

		} else

   269

			_opt_ptr->diff_level = p2;

   270

   271

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

   272

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

   273

		 * the new difficulty settings */

   274

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

   275

			ShowGameDifficulty();

   276

	}

   277

	return 0;

   278

}