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 "npf.h"

    10

#include "station.h"

    11

#include "table/train_cmd.h"

    12

#include "gfx.h"

    13

#include "news.h"

    14

#include "engine.h"

    15

#include "player.h"

    16

#include "sound.h"

    17

#include "depot.h"

    18

    19

#define is_firsthead_sprite(spritenum) \

    20

	(is_custom_sprite(spritenum) \

    21

		? is_custom_firsthead_sprite(spritenum) \

    22

		: _engine_sprite_add[spritenum] == 0)

    23

    24

static bool TrainCheckIfLineEnds(Vehicle *v);

    25

    26

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

    27

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

    28

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

    29

    30

    31

/* These two arrays are used for realistic acceleration. XXX: How should they

    32

 * be interpreted? */

    33

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

    34

	{7, 1},

    35

	{0, 2},

    36

	{1, 3},

    37

	{2, 4},

    38

	{3, 5},

    39

	{4, 6},

    40

	{5, 7},

    41

	{6, 0},

    42

};

    43

    44

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

    45

	{6, 2},

    46

	{7, 3},

    47

	{0, 4},

    48

	{1, 5},

    49

	{2, 6},

    50

	{3, 7},

    51

	{4, 0},

    52

	{5, 1},

    53

};

    54

    55

enum AccelType {

    56

	AM_ACCEL,

    57

	AM_BRAKE

    58

};

    59

    60

static bool TrainShouldStop(Vehicle *v, TileIndex tile)

    61

{

    62

	Order *o = &v->current_order;

    63

	assert(v->type == VEH_Train);

    64

	assert(IsTileType(v->tile, MP_STATION));

    65

	//When does a train drive through a station

    66

	//first we deal with the "new nonstop handling"

    67

	if ( _patches.new_nonstop && o->flags & OF_NON_STOP && _map2[tile] == o->station )

    68

		return false;

    69

    70

	if (v->last_station_visited == _map2[tile])

    71

		return false;

    72

    73

	if ( _map2[tile] != o->station && (o->flags & OF_NON_STOP || _patches.new_nonstop))

    74

		return false;

    75

    76

	return true;

    77

}

    78

    79

//new acceleration

    80

static int GetTrainAcceleration(Vehicle *v, bool mode)

    81

{

    82

	Vehicle *u = v;

    83

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

    84

	int power = 0;

    85

	int mass = 0;

    86

	int max_speed = 2000;

    87

	int area = 120;

    88

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

    89

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

    90

	int incl = 0;

    91

	int resistance;

    92

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

    93

	int force = 0x3FFFFFFF;

    94

	int pos = 0;

    95

	int lastpos = -1;

    96

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

    97

	int *dist = NULL;

    98

	int sum = 0;

    99

	int numcurve = 0;

   100

	int i;

   101

   102

	speed *= 10;

   103

	speed /= 16;

   104

   105

	//first find the curve speed limit

   106

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

   107

		int dir = u->direction;

   108

		int ndir = u->next->direction;

   109

   110

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

   111

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

   112

				curvecount[i]++;

   113

				if (lastpos != -1) {

   114

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

   115

					dist[numcurve - 1] = pos - lastpos;

   116

					if (pos - lastpos == 1) {

   117

						max_speed = 88;

   118

					}

   119

				}

   120

				lastpos = pos;

   121

			}

   122

		}

   123

   124

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

   125

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

   126

			max_speed = 61;

   127

		}

   128

	}

   129

   130

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

   131

		sum += dist[i];

   132

	}

   133

   134

	if (numcurve > 0) {

   135

		sum /= numcurve;

   136

	}

   137

   138

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

   139

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

   140

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

   141

			max_speed = 0xFFFF;

   142

		} else if (total > 1) {

   143

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

   144

		}

   145

	}

   146

   147

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

   148

   149

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

   150

		static const TileIndexDiffC _station_dir_from_vdir[] = {

   151

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

   152

		};

   153

   154

		if (TrainShouldStop(v, v->tile)) {

   155

			int station_length = 0;

   156

			TileIndex tile = v->tile;

   157

			int delta_v;

   158

   159

			max_speed = 120;

   160

			do {

   161

				station_length++;

   162

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

   163

			} while (IsTileType(tile, MP_STATION));

   164

   165

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

   166

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

   167

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

   168

   169

			max_speed = max(max_speed, 25 * station_length);

   170

		}

   171

	}

   172

   173

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

   174

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

   175

		int vmass;

   176

   177

		num++;

   178

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

   179

		drag_coeff += 3;

   180

   181

		if (rvi->max_speed != 0)

   182

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

   183

   184

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

   185

			max_speed = 61;

   186

   187

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

   188

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

   189

		mass += vmass; //[t]

   190

   191

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

   192

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

   193

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

   194

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

   195

				incl -= vmass * 60;

   196

			}

   197

		}

   198

	}

   199

   200

   201

	// these are shown in the UI

   202

	v->u.rail.cached_weight = mass;

   203

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

   204

	v->max_speed = max_speed;

   205

   206

   207

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

   208

		resistance = 13 * mass / 10;

   209

		resistance += 60 * num;

   210

		resistance += friction * mass * speed / 1000;

   211

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

   212

	} else

   213

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

   214

	resistance += incl;

   215

	resistance *= 4; //[N]

   216

   217

	if (speed > 0) {

   218

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

   219

			case 0:

   220

			case 1:

   221

			{

   222

				force = power / speed; //[N]

   223

				force *= 22;

   224

				force /= 10;

   225

			} break;

   226

			case 2:

   227

				force = power / 25;

   228

			break;

   229

		}

   230

	} else

   231

		//"kickoff" acceleration

   232

		force = resistance * 10;

   233

   234

	if (force <= 0) force = 10000;

   235

   236

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

   237

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

   238

   239

	if (mode == AM_ACCEL) {

   240

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

   241

	} else {

   242

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

   243

	}

   244

}

   245

   246

void UpdateTrainAcceleration(Vehicle *v)

   247

{

   248

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

   249

	Vehicle *u = v;

   250

   251

	assert(v->subtype == TS_Front_Engine);

   252

   253

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

   254

	do {

   255

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

   256

   257

		// power is sum of the power for all engines

   258

		power += rvi->power;

   259

   260

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

   261

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

   262

   263

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

   264

		weight += rvi->weight;

   265

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

   266

   267

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

   268

   269

	// these are shown in the UI

   270

	v->u.rail.cached_weight = weight;

   271

	v->u.rail.cached_power = power;

   272

	v->max_speed = max_speed;

   273

   274

	assert(weight != 0);

   275

   276

	// compute acceleration

   277

	acc = power / weight * 4;

   278

   279

	if (acc >= 255) acc=255;

   280

	if (acc == 0) acc++;

   281

   282

	v->acceleration = (byte)acc;

   283

}

   284

   285

int GetTrainImage(Vehicle *v, byte direction)

   286

{

   287

	int img = v->spritenum;

   288

	int base;

   289

   290

	if (is_custom_sprite(img)) {

   291

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

   292

		if (base) return base;

   293

		img = _engine_original_sprites[v->engine_type];

   294

	}

   295

   296

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

   297

   298

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

   299

		base += _wagon_full_adder[img];

   300

	return base;

   301

}

   302

   303

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

   304

{

   305

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   306

   307

	int img = rvi->image_index;

   308

	uint32 image = 0;

   309

   310

	if (is_custom_sprite(img)) {

   311

		image = GetCustomVehicleIcon(engine, 6);

   312

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

   313

	}

   314

	if (!image) {

   315

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

   316

	}

   317

   318

	if (rvi->flags & RVI_MULTIHEAD) {

   319

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

   320

		x += 15;

   321

		image = 0;

   322

		if (is_custom_sprite(img)) {

   323

			image = GetCustomVehicleIcon(engine, 2);

   324

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

   325

		}

   326

		if (!image) {

   327

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

   328

		}

   329

	}

   330

	DrawSprite(image | image_ormod, x, y);

   331

}

   332

   333

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

   334

{

   335

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   336

	int cap;

   337

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

   338

   339

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

   340

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

   341

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

   342

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

   343

   344

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

   345

   346

	cap = rvi->capacity;

   347

	SetDParam(5, STR_8838_N_A);

   348

	if (cap != 0) {

   349

		SetDParam(6, cap << multihead);

   350

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

   351

	}

   352

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   353

}

   354

   355

   356

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

   357

{

   358

	int32 value;

   359

	Vehicle *v;

   360

	const RailVehicleInfo *rvi;

   361

	int dir;

   362

	const Engine *e;

   363

	int x,y;

   364

   365

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   366

   367

	rvi = RailVehInfo(engine);

   368

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

   369

   370

	if (!(flags & DC_QUERY_COST)) {

   371

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   372

   373

		v = AllocateVehicle();

   374

		if (v == NULL)

   375

			return CMD_ERROR;

   376

   377

		if (flags & DC_EXEC) {

   378

			byte img = rvi->image_index;

   379

			Vehicle *u, *w;

   380

   381

			v->spritenum = img;

   382

   383

			u = NULL;

   384

   385

			FOR_ALL_VEHICLES(w) {

   386

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

   387

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

   388

					u = GetLastVehicleInChain(w);

   389

					break;

   390

				}

   391

			}

   392

   393

			v->engine_type = engine;

   394

   395

			dir = _map5[tile] & 3;

   396

   397

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

   398

			v->tile = (TileIndex)tile;

   399

   400

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

   401

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

   402

   403

			v->x_pos = x;

   404

			v->y_pos = y;

   405

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

   406

			v->owner = _current_player;

   407

			v->z_height = 6;

   408

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

   409

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   410

   411

			v->subtype = TS_Free_Car;

   412

			if (u != NULL) {

   413

				u->next = v;

   414

				v->subtype = TS_Not_First;

   415

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

   416

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

   417

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

   418

			} else {

   419

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

   420

			}

   421

   422

			v->cargo_type = rvi->cargo_type;

   423

			v->cargo_cap = rvi->capacity;

   424

			v->value = value;

   425

//			v->day_counter = 0;

   426

   427

			e = &_engines[engine];

   428

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

   429

   430

			v->build_year = _cur_year;

   431

			v->type = VEH_Train;

   432

			v->cur_image = 0xAC2;

   433

   434

			_new_wagon_id = v->index;

   435

   436

			VehiclePositionChanged(v);

   437

   438

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   439

		}

   440

	}

   441

   442

	return value;

   443

}

   444

   445

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

   446

static void NormalizeTrainVehInDepot(Vehicle *u)

   447

{

   448

	Vehicle *v;

   449

	FOR_ALL_VEHICLES(v) {

   450

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

   451

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

   452

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

   453

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

   454

				break;

   455

		}

   456

	}

   457

}

   458

   459

static const byte _railveh_unk1[] = {

   460

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

   461

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

   462

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

   463

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

   464

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

   465

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

   466

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

   467

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

   471

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

   475

};

   476

   477

static const byte _railveh_score[] = {

   478

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

   479

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

   480

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

   481

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

   482

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

   483

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

   484

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

   485

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

   486

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

   487

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

   488

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

   489

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

   490

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

   491

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

   492

	0, 0, 0, 0,

   493

};

   494

   495

   496

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   497

{

   498

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

   499

}

   500

   501

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

   502

{

   503

	u->direction = v->direction;

   504

	u->owner = v->owner;

   505

	u->tile = v->tile;

   506

	u->x_pos = v->x_pos;