1

     2

#include "stdafx.h"

     3

#include "ttd.h"

     4

#include "command.h"

     5

#include "player.h"

     6

#include "gfx.h"

     7

#include "window.h"

     8

#include "saveload.h"

     9

#include "economy.h"

    10

    11

/* p1 = player

    12

   p2 = face

    13

 */

    14

    15

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

    16

{

    17

	if (flags & DC_EXEC) {

    18

		DEREF_PLAYER(p1)->face = p2;

    19

		MarkWholeScreenDirty();

    20

	}

    21

	return 0;

    22

}

    23

    24

/* p1 = player

    25

 * p2 = color

    26

 */

    27

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

    28

{

    29

	Player *p,*pp;

    30

    31

//	/* can only set color for itself */

    32

//	if ( (byte)p1 != _current_player)

    33

//		return CMD_ERROR;

    34

    35

	p = DEREF_PLAYER(p1);

    36

    37

	/* ensure no dups */

    38

	FOR_ALL_PLAYERS(pp) {

    39

		if (pp->is_active && pp != p && pp->player_color == (byte)p2)

    40

			return CMD_ERROR;

    41

	}

    43

	if (flags & DC_EXEC) {

    44

		_player_colors[p1] = (byte)p2;

    45

		p->player_color = (byte)p2;

    46

		MarkWholeScreenDirty();

    47

	}

    48

	return 0;

    49

}

    50

    51

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

    52

{

    53

	Player *p;

    54

	int32 size;

    55

    56

	if ( (byte)p1 != _current_player)

    57

		return CMD_ERROR;

    58

    59

	p = DEREF_PLAYER(p1);

    60

    61

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

    62

		SET_DPARAM32(0, _economy.max_loan);

    63

		return_cmd_error(STR_702B_MAXIMUM_PERMITTED_LOAN);

    64

	}

    65

    66

	if (flags & DC_EXEC) {

    67

		if (p2)

    68

			size = _economy.max_loan - p->current_loan;

    69

		else

    70

			size = IS_HUMAN_PLAYER((byte)p1) ? 10000 : 50000;

    71

    72

		p->money64 += size;

    73

		p->current_loan += size;

    74

		UpdatePlayerMoney32(p);

    75

		InvalidatePlayerWindows(p);

    76

	}

    77

    78

	return 0;

    79

}

    80

    81

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

    82

{

    83

	Player *p;

    84

	int32 size;

    85

	if ( (byte)p1 != _current_player)

    86

		return CMD_ERROR;

    87

    88

	p = DEREF_PLAYER(p1);

    89

    90

	if (p->current_loan == 0)

    91

		return_cmd_error(STR_702D_LOAN_ALREADY_REPAYED);

    92

    93

	size = p->current_loan;

    94

    95

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

    96

	if (!p2) {

    97

	    if (_patches.ainew_active)

    98

 		    size = min(size, 10000);

    99

	    else

   100

		    size = min(size, IS_HUMAN_PLAYER((byte)p1) ? 10000 : 50000);

   101

	} else {	// only repay in chunks of 10K

   102

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

   103

		size = max(size, 10000);

   104

		size -= size % 10000;

   105

	}

   106

   107

	if (p->player_money < size) {

   108

		SET_DPARAM32(0, size);

   109

		return_cmd_error(STR_702E_REQUIRED);

   110

	}

   111

   112

	if (flags & DC_EXEC) {

   113

		p->money64 -= size;

   114

		p->current_loan -= size;

   115

		UpdatePlayerMoney32(p);

   116

		InvalidatePlayerWindows(p);

   117

	}

   118

	return 0;

   119

}

   120

   121

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

   122

{

   123

	StringID str,old_str;

   124

	Player *p;

   125

   126

	str = AllocateName((byte*)_decode_parameters, 4);

   127

	if (str == 0)

   128

		return CMD_ERROR;

   130

	if (flags & DC_EXEC) {

   131

		p = DEREF_PLAYER(p1);

   132

		old_str = p->name_1;

   133

		p->name_1 = str;

   134

		DeleteName(old_str);

   135

		MarkWholeScreenDirty();

   136

	} else {

   137

		DeleteName(str);

   138

	}

   139

   140

	return 0;

   141

}

   142

   143

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

   144

{

   145

	StringID str,old_str;

   146

	Player *p;

   147

   148

	str = AllocateName((byte*)_decode_parameters, 4);

   149

	if (str == 0)

   150

		return CMD_ERROR;

   152

	if (flags & DC_EXEC) {

   153

		p = DEREF_PLAYER(p1);

   154

		old_str = p->president_name_1;

   155

		p->president_name_1 = str;

   156

		DeleteName(old_str);

   157

   158

		if (p->name_1 == STR_SV_UNNAMED) {

   159

			byte *s = " Transport";

   160

			byte *d = (byte*)_decode_parameters, b;

   161

			d--; do d++; while (*d);

   162

			do *d++ = b = *s++; while(d != (byte*)endof(_decode_parameters) && b != 0);

   163

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

   165

		MarkWholeScreenDirty();

   166

	} else {

   167

		DeleteName(str);

   168

	}

   169

   171

}

   172

   173

static void UpdateSignVirtCoords(SignStruct *ss)

   174

{

   175

	Point pt = RemapCoords(ss->x, ss->y, ss->z);

   176

	SET_DPARAM16(0, ss->str);

   177

	UpdateViewportSignPos(&ss->sign, pt.x, pt.y - 6, STR_2806);

   178

}

   179

   180

void UpdateAllSignVirtCoords()

   181

{

   182

	SignStruct *ss;

   183

	for(ss=_sign_list; ss != endof(_sign_list); ss++)

   184

		if (ss->str != 0)

   185

			UpdateSignVirtCoords(ss);

   186

   187

}

   188

   189

static void MarkSignDirty(SignStruct *ss)

   190

{

   191

	MarkAllViewportsDirty(

   192

		ss->sign.left-6,

   193

		ss->sign.top-3,

   194

		ss->sign.left+ss->sign.width_1*4+12,

   195

		ss->sign.top + 45

   196

	);

   197

}

   198

   199

   200

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

   201

{

   202

	SignStruct *ss;

   204

	for(ss=_sign_list; ss != endof(_sign_list); ss++) {

   205

		if (ss->str == 0) {

   206

			if (flags & DC_EXEC) {

   207

				ss->str = STR_280A_SIGN;

   208

				ss->x = x;

   209

				ss->y = y;

   210

				ss->z = GetSlopeZ(x,y);

   211

				UpdateSignVirtCoords(ss);

   212

				MarkSignDirty(ss);

   213

				_new_sign_struct = ss;

   214

			}

   215

			return 0;

   217

	}

   218

   219

	return_cmd_error(STR_2808_TOO_MANY_SIGNS);

   220

}

   221

   222

// p1 = sign index

   223

// p2: 1 -> remove sign

   224

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

   225

{

   226

	StringID str,old_str;

   227

	SignStruct *ss;

   228

   229

	if (_decode_parameters[0] != 0 && !p2) {

   230

		str = AllocateName((byte*)_decode_parameters, 0);

   231

		if (str == 0)

   232

			return CMD_ERROR;

   233

   234

		if (flags & DC_EXEC) {

   235

			ss = &_sign_list[p1];

   236

			MarkSignDirty(ss);

   237

			DeleteName(ss->str);

   238

			ss->str = str;

   239

			UpdateSignVirtCoords(ss);

   240

			MarkSignDirty(ss);

   241

		} else {

   242

			DeleteName(str);

   243

		}

   244

	}	else {

   245

		if (flags & DC_EXEC) {

   246

			ss = &_sign_list[p1];

   247

			old_str = ss->str;

   248

			ss->str = 0;

   249

			DeleteName(old_str);

   250

			MarkSignDirty(ss);

   251

		}

   252

	}

   253

	return 0;

   254

}

   255

   256

// p1 = 0   decrease pause counter

   257

// p1 = 1   increase pause counter

   258

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

   259

{

   260

	if (flags & DC_EXEC) {

   261

		_pause += p1?1:-1;

   262

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

   263

		InvalidateWindow(WC_STATUS_BAR, 0);

   264

		InvalidateWindow(WC_MAIN_TOOLBAR, 0);

   265

	}

   266

	return 0;

   267

}

   268

   269

   270

   271

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

   272

{

   273

	return 0;

   274

}

   275

   276

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

   277

{

   279

	return (int32)p1;

   280

}

   281

   282

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

   283

{

   284

	if (flags & DC_EXEC) {

   285

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

   286

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

   287

			_opt_mod_ptr->diff_level = 3;

   288

		} else {

   289

			_opt_mod_ptr->diff_level = p2;

   290

		}

   291

		InvalidateWindow(WC_GAME_OPTIONS, 0);

   292

	}

   294

}

   295

   296

static const byte _sign_desc[] = {

   297

	SLE_VAR(SignStruct,str,						SLE_UINT16),

   298

	SLE_VAR(SignStruct,x,							SLE_INT16),

   299

	SLE_VAR(SignStruct,y,							SLE_INT16),

   300

	SLE_VAR(SignStruct,z,							SLE_UINT8),

   301

	SLE_END()

   302

};

   303

   304

static void Save_SIGN()

   305

{

   306

	SignStruct *s;

   307

	int i;

   308

	for(i=0,s=_sign_list; i!=lengthof(_sign_list); i++,s++) {

   309

		if (s->str != 0) {

   310

			SlSetArrayIndex(i);

   311

			SlObject(s, _sign_desc);

   312

		}

   313

	}

   314

}

   315

   316

static void Load_SIGN()

   317

{

   318

	int index;

   319

	while ((index = SlIterateArray()) != -1) {

   320

		SlObject(&_sign_list[index], _sign_desc);

   321

	}

   322

}

   323

   324

const ChunkHandler _sign_chunk_handlers[] = {

   325

	{ 'SIGN', Save_SIGN, Load_SIGN, CH_ARRAY | CH_LAST},

   326

};

   327

   328