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

    65

//new acceleration

    66

static int GetTrainAcceleration(Vehicle *v, bool mode)

    67

{

    68

	Vehicle *u = v;

    69

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

    70

	int power = 0;

    71

	int mass = 0;

    72

	int max_speed = 2000;

    73

	int area = 120;

    74

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

    75

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

    76

	int incl = 0;

    77

	int resistance;

    78

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

    79

	int force = 0x3FFFFFFF;

    80

	int pos = 0;

    81

	int lastpos = -1;

    82

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

    83

	int *dist = NULL;

    84

	int sum = 0;

    85

	int numcurve = 0;

    86

	int i;

    87

    88

	speed *= 10;

    89

	speed /= 16;

    90

    91

	//first find the curve speed limit

    92

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

    93

		int dir = u->direction;

    94

		int ndir = u->next->direction;

    95

    96

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

    97

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

    98

				curvecount[i]++;

    99

				if (lastpos != -1) {

   100

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

   101

					dist[numcurve - 1] = pos - lastpos;

   102

					if (pos - lastpos == 1) {

   103

						max_speed = 88;

   104

					}

   105

				}

   106

				lastpos = pos;

   107

			}

   108

		}

   109

   110

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

   111

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

   112

			max_speed = 61;

   113

		}

   114

	}

   115

   116

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

   117

		sum += dist[i];

   118

	}

   119

   120

	if (numcurve > 0) {

   121

		sum /= numcurve;

   122

	}

   123

   124

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

   125

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

   126

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

   127

			max_speed = 0xFFFF;

   128

		} else if (total > 1) {

   129

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

   130

		}

   131

	}

   132

   133

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

   134

   135

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

   136

		static const TileIndexDiffC _station_dir_from_vdir[] = {

   137

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

   138

		};

   139

   140

		if (((v->current_order.station == _map2[v->tile]) || !(v->current_order.flags & OF_NON_STOP)) && v->last_station_visited != _map2[v->tile]) {

   141

			int station_length = 0;

   142

			TileIndex tile = v->tile;

   143

			int delta_v;

   144

   145

			max_speed = 120;

   146

			do {

   147

				station_length++;

   148

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

   149

			} while (IsTileType(tile, MP_STATION));

   150

   151

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

   152

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

   153

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

   154

   155

			max_speed = max(max_speed, 25 * station_length);

   156

		}

   157

	}

   158

   159

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

   160

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

   161

		int vmass;

   162

   163

		num++;

   164

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

   165

		drag_coeff += 3;

   166

   167

		if (rvi->max_speed != 0)

   168

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

   169

   170

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

   171

			max_speed = 61;

   172

   173

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

   174

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

   175

		mass += vmass; //[t]

   176

   177

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

   178

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

   179

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

   180

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

   181

				incl -= vmass * 60;

   182

			}

   183

		}

   184

	}

   185

   186

   187

	// these are shown in the UI

   188

	v->u.rail.cached_weight = mass;

   189

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

   190

	v->max_speed = max_speed;

   191

   192

   193

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

   194

		resistance = 13 * mass / 10;

   195

		resistance += 60 * num;

   196

		resistance += friction * mass * speed / 1000;

   197

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

   198

	} else

   199

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

   200

	resistance += incl;

   201

	resistance *= 4; //[N]

   202

   203

	if (speed > 0) {

   204

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

   205

			case 0:

   206

			case 1:

   207

			{

   208

				force = power / speed; //[N]

   209

				force *= 22;

   210

				force /= 10;

   211

			} break;

   212

			case 2:

   213

				force = power / 25;

   214

			break;

   215

		}

   216

	} else

   217

		//"kickoff" acceleration

   218

		force = resistance * 10;

   219

   220

	if (force <= 0) force = 10000;

   221

   222

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

   223

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

   224

   225

	if (mode == AM_ACCEL) {

   226

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

   227

	} else {

   228

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

   229

	}

   230

}

   231

   232

void UpdateTrainAcceleration(Vehicle *v)

   233

{

   234

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

   235

	Vehicle *u = v;

   236

   237

	assert(v->subtype == TS_Front_Engine);

   238

   239

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

   240

	do {

   241

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

   242

   243

		// power is sum of the power for all engines

   244

		power += rvi->power;

   245

   246

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

   247

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

   248

   249

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

   250

		weight += rvi->weight;

   251

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

   252

   253

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

   254

   255

	// these are shown in the UI

   256

	v->u.rail.cached_weight = weight;

   257

	v->u.rail.cached_power = power;

   258

	v->max_speed = max_speed;

   259

   260

	assert(weight != 0);

   261

   262

	// compute acceleration

   263

	acc = power / weight * 4;

   264

   265

	if (acc >= 255) acc=255;

   266

	if (acc == 0) acc++;

   267

   268

	v->acceleration = (byte)acc;

   269

}

   270

   271

int GetTrainImage(Vehicle *v, byte direction)

   272

{

   273

	int img = v->spritenum;

   274

	int base;

   275

   276

	if (is_custom_sprite(img)) {

   277

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

   278

		if (base) return base;

   279

		img = _engine_original_sprites[v->engine_type];

   280

	}

   281

   282

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

   283

   284

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

   285

		base += _wagon_full_adder[img];

   286

	return base;

   287

}

   288

   289

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

   290

{

   291

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   292

   293

	int img = rvi->image_index;

   294

	uint32 image = 0;

   295

   296

	if (is_custom_sprite(img)) {

   297

		image = GetCustomVehicleIcon(engine, 6);

   298

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

   299

	}

   300

	if (!image) {

   301

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

   302

	}

   303

   304

	if (rvi->flags & RVI_MULTIHEAD) {

   305

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

   306

		x += 15;

   307

		image = 0;

   308

		if (is_custom_sprite(img)) {

   309

			image = GetCustomVehicleIcon(engine, 2);

   310

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

   311

		}

   312

		if (!image) {

   313

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

   314

		}

   315

	}

   316

	DrawSprite(image | image_ormod, x, y);

   317

}

   318

   319

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

   320

{

   321

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   322

	int cap;

   323

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

   324

   325

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

   326

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

   327

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

   328

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

   329

   330

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

   331

   332

	cap = rvi->capacity;

   333

	SetDParam(5, STR_8838_N_A);

   334

	if (cap != 0) {

   335

		SetDParam(6, cap << multihead);

   336

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

   337

	}

   338

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   339

}

   340

   341

   342

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

   343

{

   344

	int32 value;

   345

	Vehicle *v;

   346

	const RailVehicleInfo *rvi;

   347

	int dir;

   348

	const Engine *e;

   349

	int x,y;

   350

   351

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   352

   353

	rvi = RailVehInfo(engine);

   354

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

   355

   356

	if (!(flags & DC_QUERY_COST)) {

   357

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   358

   359

		v = AllocateVehicle();

   360

		if (v == NULL)

   361

			return CMD_ERROR;

   362

   363

		if (flags & DC_EXEC) {

   364

			byte img = rvi->image_index;

   365

			Vehicle *u, *w;

   366

   367

			v->spritenum = img;

   368

   369

			u = NULL;

   370

   371

			FOR_ALL_VEHICLES(w) {

   372

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

   373

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

   374

					u = GetLastVehicleInChain(w);

   375

					break;

   376

				}

   377

			}

   378

   379

			v->engine_type = engine;

   380

   381

			dir = _map5[tile] & 3;

   382

   383

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

   384

			v->tile = (TileIndex)tile;

   385

   386

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

   387

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

   388

   389

			v->x_pos = x;

   390

			v->y_pos = y;

   391

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

   392

			v->owner = _current_player;

   393

			v->z_height = 6;

   394

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

   395

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   396

   397

			v->subtype = TS_Free_Car;

   398

			if (u != NULL) {

   399

				u->next = v;

   400

				v->subtype = TS_Not_First;

   401

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

   402

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

   403

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

   404

			} else {

   405

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

   406

			}

   407

   408

			v->cargo_type = rvi->cargo_type;

   409

			v->cargo_cap = rvi->capacity;

   410

			v->value = value;

   411

//			v->day_counter = 0;

   412

   413

			e = &_engines[engine];

   414

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

   415

   416

			v->build_year = _cur_year;

   417

			v->type = VEH_Train;

   418

			v->cur_image = 0xAC2;

   419

   420

			_new_wagon_id = v->index;

   421

   422

			VehiclePositionChanged(v);

   423

   424

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   425

		}

   426

	}

   427

   428

	return value;

   429

}

   430

   431

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

   432

static void NormalizeTrainVehInDepot(Vehicle *u)

   433

{

   434

	Vehicle *v;

   435

	FOR_ALL_VEHICLES(v) {

   436

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

   437

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

   438

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

   439

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

   440

				break;

   441

		}

   442

	}

   443

}

   444

   445

static const byte _railveh_unk1[] = {

   446

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

   447

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

   448

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

   449

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

   450

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

   451

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

   452

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

   453

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

   454

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

   455

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

   456

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

   457

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

   458

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

   459

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

   460

	0, 0, 0, 0,

   461

};

   462

   463

static const byte _railveh_score[] = {

   464

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

   465

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

   466

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

   467

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

   468

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

   469

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

   470

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

   471

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

   472

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

   473

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

   474

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

   475

	74, 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,

   479

};

   480

   481

   482

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   483

{

   484

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

   485

}

   486

   487

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

   488

{

   489

	u->direction = v->direction;

   490

	u->owner = v->owner;

   491

	u->tile = v->tile;

   492

	u->x_pos = v->x_pos;

   493

	u->y_pos = v->y_pos;

   494

	u->z_pos = v->z_pos;

   495

	u->z_height = 6;

   496

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

   497

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

   498

	u->vehstatus = v->vehstatus & ~VS_STOPPED;

   499

	u->subtype = TS_Not_First;

   500

	u->spritenum = v->spritenum + 1;

   501

	u->cargo_type = v->cargo_type;

   502

	u->cargo_cap = v->cargo_cap;

   503

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

   504

	if (building) v->next = u;

   505

	u->engine_type = v->engine_type;

   506

	u->build_year = v->build_year;

   507

	if (building)