1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "vehicle.h"

     7

#include "command.h"

     8

#include "pathfind.h"

     9

#include "station.h"

    10

#include "table/train_cmd.h"

    11

#include "gfx.h"

    12

#include "news.h"

    13

#include "engine.h"

    14

#include "player.h"

    15

#include "sound.h"

    16

    17

#define is_firsthead_sprite(spritenum) \

    18

	(is_custom_sprite(spritenum) \

    19

		? is_custom_firsthead_sprite(spritenum) \

    20

		: _engine_sprite_add[spritenum] == 0)

    21

    22

static bool TrainCheckIfLineEnds(Vehicle *v);

    23

    24

static const byte _vehicle_initial_x_fract[4] = {10,8,4,8};

    25

static const byte _vehicle_initial_y_fract[4] = {8,4,8,10};

    26

static const byte _state_dir_table[4] = { 0x20, 8, 0x10, 4 };

    27

    28

static const byte _signal_onedir[14] = {

    29

	0x80, 0x80, 0x80, 0x20, 0x40, 0x10, 0, 0,

    30

	0x40, 0x40, 0x40, 0x10, 0x80, 0x20

    31

};

    32

    33

static const byte _signal_otherdir[14] = {

    34

	0x40, 0x40, 0x40, 0x10, 0x80, 0x20, 0, 0,

    35

	0x80, 0x80, 0x80, 0x20, 0x40, 0x10

    36

};

    37

    38

static const byte _curve_neighbours45[8][2] = {

    39

	{7, 1},

    40

	{0, 2},

    41

	{1, 3},

    42

	{2, 4},

    43

	{3, 5},

    44

	{4, 6},

    45

	{5, 7},

    46

	{6, 0},

    47

};

    48

    49

static const byte _curve_neighbours90[8][2] = {

    50

	{6, 2},

    51

	{7, 3},

    52

	{0, 4},

    53

	{1, 5},

    54

	{2, 6},

    55

	{3, 7},

    56

	{4, 0},

    57

	{5, 1},

    58

};

    59

    60

enum AccelType {

    61

	AM_ACCEL,

    62

	AM_BRAKE

    63

};

    64

    84

//new acceleration

    85

static int GetTrainAcceleration(Vehicle *v, bool mode)

    86

{

    87

	Vehicle *u = v;

    88

	int num = 0;	//number of vehicles, change this into the number of axles later

    89

	int power = 0;

    90

	int mass = 0;

    91

	int max_speed = 2000;

    92

	int area = 120;

    93

	int friction = 35; //[1e-3]

    94

	int drag_coeff = 20;	//[1e-4]

    95

	int incl = 0;

    96

	int resistance;

    97

	int speed = v->cur_speed; //[mph]

    98

	int force = 0x3FFFFFFF;

    99

	int pos = 0;

   100

	int lastpos = -1;

   101

	int curvecount[2] = {0, 0};

   102

	int *dist = NULL;

   103

	int sum = 0;

   104

	int numcurve = 0;

   105

	int i;

   106

   107

	speed *= 10;

   108

	speed /= 16;

   109

   110

	//first find the curve speed limit

   111

	for (; u->next != NULL; u = u->next, pos++) {

   112

		int dir = u->direction;

   113

		int ndir = u->next->direction;

   114

   115

		for (i = 0; i < 2; i++) {

   116

			if ( _curve_neighbours45[dir][i] == ndir) {

   117

				curvecount[i]++;

   118

				if (lastpos != -1) {

   119

					dist = realloc(dist, sizeof(int) * ++numcurve);

   120

					dist[numcurve - 1] = pos - lastpos;

   121

					if (pos - lastpos == 1) {

   122

						max_speed = 88;

   123

					}

   124

				}

   125

				lastpos = pos;

   126

			}

   127

		}

   128

   129

		//if we have a 90 degree turn, fix the speed limit to 60

   130

		if ( _curve_neighbours90[dir][0] == ndir || _curve_neighbours90[dir][1] == ndir) {

   131

			max_speed = 61;

   132

		}

   133

	}

   134

   135

	for(i = 0; i < numcurve; i++) {

   136

		sum += dist[i];

   137

	}

   138

   139

	if (numcurve > 0) {

   140

		sum /= numcurve;

   141

	}

   142

   143

	if ((curvecount[0] != 0 || curvecount[1] != 0) && (max_speed > 88)) {

   144

		int total = curvecount[0] + curvecount[1];

   145

		if (curvecount[0] == 1 && curvecount[1] == 1) {

   146

			max_speed = 0xFFFF;

   147

		} else if (total > 1) {

   148

			max_speed = 232 - (13 - clamp(sum, 1, 12)) * (13 - clamp(sum, 1, 12));

   149

		}

   150

	}

   151

   152

	max_speed += (max_speed / 2) * v->u.rail.railtype;

   153

   154

	if (IsTileType(v->tile, MP_STATION) && v->subtype == TS_Front_Engine) {

   155

		static const TileIndexDiffC _station_dir_from_vdir[] = {

   156

			{0, 0}, {-1, 0}, {0, 0}, {0, 1}, {0, 0}, {1, 0}, {0, 0}, {0, -1}

   157

		};

   158

   160

			int station_length = 0;

   161

			TileIndex tile = v->tile;

   162

			int delta_v;

   163

   164

			max_speed = 120;

   165

			do {

   166

				station_length++;

   167

				tile = TILE_ADD(tile, ToTileIndexDiff(_station_dir_from_vdir[v->direction]));

   168

			} while (IsTileType(tile, MP_STATION));

   169

   170

			delta_v = v->cur_speed / (station_length + 1);

   171

			if (v->max_speed > (v->cur_speed - delta_v))

   172

				max_speed = v->cur_speed - (delta_v / 10);

   173

   174

			max_speed = max(max_speed, 25 * station_length);

   175

		}

   176

	}

   177

   178

	for (u = v; u != NULL; u = u->next) {

   179

		const RailVehicleInfo *rvi = RailVehInfo(u->engine_type);

   180

		int vmass;

   181

   182

		num++;

   183

		power += rvi->power * 746;	//[W]

   184

		drag_coeff += 3;

   185

   186

		if (rvi->max_speed != 0)

   187

			max_speed = min(rvi->max_speed, max_speed);

   188

   189

		if (u->u.rail.track == 0x80)

   190

			max_speed = 61;

   191

   192

		vmass = rvi->weight;  //[t]

   193

		vmass += (_cargoc.weights[u->cargo_type] * u->cargo_count) / 16;

   194

		mass += vmass; //[t]

   195

   196

		if (!IsTileType(u->tile, MP_TUNNELBRIDGE)) {

   197

			if (HASBIT(u->u.rail.flags, VRF_GOINGUP)) {

   198

				incl += vmass * 60;		//3% slope, quite a bit actually

   199

			} else if (HASBIT(u->u.rail.flags, VRF_GOINGDOWN)) {

   200

				incl -= vmass * 60;

   201

			}

   202

		}

   203

	}

   204

   205

   206

	// these are shown in the UI

   207

	v->u.rail.cached_weight = mass;

   208

	v->u.rail.cached_power = power / 746;

   209

	v->max_speed = max_speed;

   210

   211

   212

	if (v->u.rail.railtype != 2) {

   213

		resistance = 13 * mass / 10;

   214

		resistance += 60 * num;

   215

		resistance += friction * mass * speed / 1000;

   216

		resistance += (area * drag_coeff * speed * speed) / 10000;

   217

	} else

   218

		resistance = (area * (drag_coeff / 2) * speed * speed) / 10000;

   219

	resistance += incl;

   220

	resistance *= 4; //[N]

   221

   222

	if (speed > 0) {

   223

		switch (v->u.rail.railtype) {

   224

			case 0:

   225

			case 1:

   226

			{

   227

				force = power / speed; //[N]

   228

				force *= 22;

   229

				force /= 10;

   230

			} break;

   231

			case 2:

   232

				force = power / 25;

   233

			break;

   234

		}

   235

	} else

   236

		//"kickoff" acceleration

   237

		force = resistance * 10;

   238

   239

	if (force <= 0) force = 10000;

   240

   241

	if (v->u.rail.railtype != 2)

   242

		force = min(force, mass * 10 * 200);

   243

   244

	if (mode == AM_ACCEL) {

   245

		return (force - resistance) / (mass * 4);

   246

	} else {

   247

		return min((-force - resistance) /(mass * 4), (10000 / (mass * 4)));

   248

	}

   249

}

   250

   251

void UpdateTrainAcceleration(Vehicle *v)

   252

{

   253

	uint acc, power=0, max_speed=5000, weight=0;

   254

	Vehicle *u = v;

   255

   256

	assert(v->subtype == TS_Front_Engine);

   257

   258

	// compute stuff like max speed, power, and weight.

   259

	do {

   260

		const RailVehicleInfo *rvi = RailVehInfo(u->engine_type);

   261

   262

		// power is sum of the power for all engines

   263

		power += rvi->power;

   264

   265

		// limit the max speed to the speed of the slowest vehicle.

   266

		if (rvi->max_speed && rvi->max_speed <= max_speed) max_speed = rvi->max_speed;

   267

   268

		// weight is the sum of the weight of the wagon and the weight of the cargo.

   269

		weight += rvi->weight;

   270

		weight += (_cargoc.weights[u->cargo_type] * u->cargo_count) >> 4;

   271

   272

	} while ( (u=u->next) != NULL);

   273

   274

	// these are shown in the UI

   275

	v->u.rail.cached_weight = weight;

   276

	v->u.rail.cached_power = power;

   277

	v->max_speed = max_speed;

   278

   279

	assert(weight != 0);

   280

   281

	// compute acceleration

   282

	acc = power / weight * 4;

   283

   284

	if (acc >= 255) acc=255;

   285

	if (acc == 0) acc++;

   286

   287

	v->acceleration = (byte)acc;

   288

}

   289

   290

int GetTrainImage(Vehicle *v, byte direction)

   291

{

   292

	int img = v->spritenum;

   293

	int base;

   294

   295

	if (is_custom_sprite(img)) {

   296

		base = GetCustomVehicleSprite(v, direction + 4 * is_custom_secondhead_sprite(img));

   297

		if (base) return base;

   298

		img = _engine_original_sprites[v->engine_type];

   299

	}

   300

   301

	base = _engine_sprite_base[img] + ((direction + _engine_sprite_add[img]) & _engine_sprite_and[img]);

   302

   303

	if (v->cargo_count >= (v->cargo_cap >> 1))

   304

		base += _wagon_full_adder[img];

   305

	return base;

   306

}

   307

   308

void DrawTrainEngine(int x, int y, int engine, uint32 image_ormod)

   309

{

   310

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   311

   312

	int img = rvi->image_index;

   313

	uint32 image = 0;

   314

   315

	if (is_custom_sprite(img)) {

   316

		image = GetCustomVehicleIcon(engine, 6);

   317

		if (!image) img = _engine_original_sprites[engine];

   318

	}

   319

	if (!image) {

   320

		image = (6 & _engine_sprite_and[img]) + _engine_sprite_base[img];

   321

	}

   322

   323

	if (rvi->flags & RVI_MULTIHEAD) {

   324

		DrawSprite(image | image_ormod, x-14, y);

   325

		x += 15;

   326

		image = 0;

   327

		if (is_custom_sprite(img)) {

   328

			image = GetCustomVehicleIcon(engine, 2);

   329

			if (!image) img = _engine_original_sprites[engine];

   330

		}

   331

		if (!image) {

   332

			image = ((6 + _engine_sprite_add[img+1]) & _engine_sprite_and[img+1]) + _engine_sprite_base[img+1];

   333

		}

   334

	}

   335

	DrawSprite(image | image_ormod, x, y);

   336

}

   337

   338

void DrawTrainEngineInfo(int engine, int x, int y, int maxw)

   339

{

   340

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   341

	int cap;

   342

	uint multihead = ((rvi->flags & RVI_MULTIHEAD) ? 1 : 0);

   343

   344

	SetDParam(0, ((_price.build_railvehicle >> 3) * rvi->base_cost) >> 5);

   345

	SetDParam(2, rvi->max_speed * 10 >> 4);

   346

	SetDParam(3, rvi->power << multihead);

   347

	SetDParam(1, rvi->weight << multihead);

   348

   349

	SetDParam(4, (rvi->running_cost_base * _price.running_rail[rvi->engclass] >> 8) << multihead);

   350

   351

	cap = rvi->capacity;

   352

	SetDParam(5, STR_8838_N_A);

   353

	if (cap != 0) {

   354

		SetDParam(6, cap << multihead);

   355

		SetDParam(5, _cargoc.names_long_p[rvi->cargo_type]);

   356

	}

   357

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   358

}

   359

   360

   361

static int32 CmdBuildRailWagon(uint engine, uint tile, uint32 flags)

   362

{

   363

	int32 value;

   364

	Vehicle *v;

   365

	const RailVehicleInfo *rvi;

   366

	int dir;

   367

	const Engine *e;

   368

	int x,y;

   369

   370

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   371

   372

	rvi = RailVehInfo(engine);

   373

	value = (rvi->base_cost * _price.build_railwagon) >> 8;

   374

   375

	if (!(flags & DC_QUERY_COST)) {

   376

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   377

   378

		v = AllocateVehicle();

   379

		if (v == NULL)

   380

			return CMD_ERROR;

   381

   382

		if (flags & DC_EXEC) {

   383

			byte img = rvi->image_index;

   384

			Vehicle *u, *w;

   385

   386

			v->spritenum = img;

   387

   388

			u = NULL;

   389

   390

			FOR_ALL_VEHICLES(w) {

   391

				if (w->type == VEH_Train && w->tile == (TileIndex)tile &&

   392

				    w->subtype == TS_Free_Car && w->engine_type == engine) {

   393

					u = GetLastVehicleInChain(w);

   394

					break;

   395

				}

   396

			}

   397

   398

			v->engine_type = engine;

   399

   400

			dir = _map5[tile] & 3;

   401

   402

			v->direction = (byte)(dir*2+1);

   403

			v->tile = (TileIndex)tile;

   404

   405

			x = TileX(tile) * 16 | _vehicle_initial_x_fract[dir];

   406

			y = TileY(tile) * 16 | _vehicle_initial_y_fract[dir];

   407

   408

			v->x_pos = x;

   409

			v->y_pos = y;

   410

			v->z_pos = GetSlopeZ(x,y);

   411

			v->owner = _current_player;

   412

			v->z_height = 6;

   413

			v->u.rail.track = 0x80;

   414

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   415

   416

			v->subtype = TS_Free_Car;

   417

			if (u != NULL) {

   418

				u->next = v;

   419

				v->subtype = TS_Not_First;

   420

				v->u.rail.first_engine = u->u.rail.first_engine;

   421

				if (v->u.rail.first_engine == 0xffff && u->subtype == TS_Front_Engine )

   422

					v->u.rail.first_engine = u->engine_type;

   423

			} else {

   424

				v->u.rail.first_engine = 0xffff;

   425

			}

   426

   427

			v->cargo_type = rvi->cargo_type;

   428

			v->cargo_cap = rvi->capacity;

   429

			v->value = value;

   430

//			v->day_counter = 0;

   431

   432

			e = &_engines[engine];

   433

			v->u.rail.railtype = e->railtype;

   434

   435

			v->build_year = _cur_year;

   436

			v->type = VEH_Train;

   437

			v->cur_image = 0xAC2;

   438

   439

			_new_wagon_id = v->index;

   440

   441

			VehiclePositionChanged(v);

   442

   443

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   444

		}

   445

	}

   446

   447

	return value;

   448

}

   449

   450

// Move all free vehicles in the depot to the train

   451

static void NormalizeTrainVehInDepot(Vehicle *u)

   452

{

   453

	Vehicle *v;

   454

	FOR_ALL_VEHICLES(v) {

   455

		if (v->type == VEH_Train && v->subtype == TS_Free_Car &&

   456

				v->tile == u->tile &&

   457

				v->u.rail.track == 0x80) {

   458

			if (DoCommandByTile(0,v->index | (u->index<<16), 1, DC_EXEC, CMD_MOVE_RAIL_VEHICLE) == CMD_ERROR)

   459

				break;

   460

		}

   461

	}

   462

}

   463

   464

static const byte _railveh_unk1[] = {

   465

	0, 0, 0, 0, 0, 0, 0, 0,

   466

	0, 0, 0, 1, 1, 0, 0, 0,

   467

	0, 0, 0, 0, 1, 0, 1, 0,

   468

	0, 1, 1, 0, 0, 0, 0, 0,

   469

	0, 0, 0, 0, 0, 0, 0, 0,

   470

	0, 0, 0, 0, 0, 0, 0, 0,

   471

	0, 0, 0, 0, 0, 0, 0, 1,

   472

	0, 0, 0, 0, 0, 0, 0, 0,

   473

	0, 0, 0, 0, 0, 0, 0, 0,

   474

	0, 0, 0, 0, 0, 0, 0, 0,

   475

	0, 0, 0, 0, 0, 0, 0, 0,

   476

	0, 0, 0, 0, 0, 0, 0, 0,

   477

	0, 0, 0, 0, 0, 0, 0, 0,

   478

	0, 0, 0, 0, 0, 0, 0, 0,

   479

	0, 0, 0, 0,

   480

};

   481

   482

static const byte _railveh_score[] = {

   483

	1, 4, 7, 19, 20, 30, 31, 19,

   484

	20, 21, 22, 10, 11, 30, 31, 32,

   485

	33, 34, 35, 29, 45, 32, 50, 40,

   486

	41, 51, 52, 0, 0, 0, 0, 0,

   487

	0, 0, 0, 0, 0, 0, 0, 0,

   488

	0, 0, 0, 0, 0, 0, 0, 0,

   489

	0, 0, 0, 0, 0, 0, 60, 62,

   490

	63, 0, 0, 0, 0, 0, 0, 0,

   491

	0, 0, 0, 0, 0, 0, 0, 0,

   492

	0, 0, 0, 0, 0, 0, 0, 0,

   493

	0, 0, 0, 0, 70, 71, 72, 73,

   494

	74, 0, 0, 0, 0, 0, 0, 0,

   495

	0, 0, 0, 0, 0, 0, 0, 0,

   496

	0, 0, 0, 0, 0, 0, 0, 0,

   497

	0, 0, 0, 0,

   498

};

   499

   500

   501

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   502

{

   503

	return (rvi->base_cost * (_price.build_railvehicle >> 3)) >> 5;

   504

}

   505

   506

void AddRearEngineToMultiheadedTrain(Vehicle *v, Vehicle *u, bool building)

   507

{