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

#include "waypoint.h"

    19

    20

#define is_firsthead_sprite(spritenum) \

    21

	(is_custom_sprite(spritenum) \

    22

		? is_custom_firsthead_sprite(spritenum) \

    23

		: _engine_sprite_add[spritenum] == 0)

    24

    25

static bool TrainCheckIfLineEnds(Vehicle *v);

    26

    27

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

    28

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

    29

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

    30

    31

    32

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

    33

 * be interpreted? */

    34

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

    35

	{7, 1},

    36

	{0, 2},

    37

	{1, 3},

    38

	{2, 4},

    39

	{3, 5},

    40

	{4, 6},

    41

	{5, 7},

    42

	{6, 0},

    43

};

    44

    45

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

    46

	{6, 2},

    47

	{7, 3},

    48

	{0, 4},

    49

	{1, 5},

    50

	{2, 6},

    51

	{3, 7},

    52

	{4, 0},

    53

	{5, 1},

    54

};

    55

    56

enum AccelType {

    57

	AM_ACCEL,

    58

	AM_BRAKE

    59

};

    60

    61

static bool TrainShouldStop(Vehicle *v, TileIndex tile)

    62

{

    63

	Order *o = &v->current_order;

    64

	assert(v->type == VEH_Train);

    65

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

    66

	//When does a train drive through a station

    67

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

    68

	if (_patches.new_nonstop && o->flags & OF_NON_STOP &&

    69

			_map2[tile] == o->station )

    70

		return false;

    71

    72

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

    73

		return false;

    74

    75

	if (_map2[tile] != o->station &&

    76

			(o->flags & OF_NON_STOP || _patches.new_nonstop))

    77

		return false;

    78

    79

	return true;

    80

}

    81

    82

//new acceleration

    83

static int GetTrainAcceleration(Vehicle *v, bool mode)

    84

{

    85

	const Vehicle *u;

    86

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

    87

	int power = 0;

    88

	int mass = 0;

    89

	int max_speed = 2000;

    90

	int area = 120;

    91

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

    92

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

    93

	int incl = 0;

    94

	int resistance;

    95

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

    96

	int force = 0x3FFFFFFF;

    97

	int pos = 0;

    98

	int lastpos = -1;

    99

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

   100

	int sum = 0;

   101

	int numcurve = 0;

   102

   103

	speed *= 10;

   104

	speed /= 16;

   105

   106

	//first find the curve speed limit

   107

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

   108

		int dir = u->direction;

   109

		int ndir = u->next->direction;

   110

		int i;

   111

   112

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

   113

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

   114

				curvecount[i]++;

   115

				if (lastpos != -1) {

   116

					numcurve++;

   117

					sum += pos - lastpos;

   118

					if (pos - lastpos == 1) {

   119

						max_speed = 88;

   120

					}

   121

				}

   122

				lastpos = pos;

   123

			}

   124

		}

   125

   126

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

   127

		if (_curve_neighbours90[dir][0] == ndir ||

   128

				_curve_neighbours90[dir][1] == ndir) {

   129

			max_speed = 61;

   130

		}

   131

	}

   132

   133

	if (numcurve > 0) sum /= numcurve;

   134

   135

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

   136

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

   137

   138

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

   139

			max_speed = 0xFFFF;

   140

		} else if (total > 1) {

   141

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

   142

		}

   143

	}

   144

   145

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

   146

   147

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

   148

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

   149

			int station_length = 0;

   150

			TileIndex tile = v->tile;

   151

			int delta_v;

   152

   153

			max_speed = 120;

   154

			do {

   155

				station_length++;

   156

				tile = TILE_ADD(tile, TileOffsByDir(v->direction / 2));

   157

			} while (IsTileType(tile, MP_STATION));

   158

   159

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

   160

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

   161

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

   162

   163

			max_speed = max(max_speed, 25 * station_length);

   164

		}

   165

	}

   166

   167

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

   168

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

   169

		int vmass;

   170

   171

		num++;

   172

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

   173

		drag_coeff += 3;

   174

   175

		if (rvi->max_speed != 0)

   176

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

   177

   178

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

   179

			max_speed = 61;

   180

   181

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

   182

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

   183

		mass += vmass; //[t]

   184

   185

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

   186

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

   187

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

   188

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

   189

				incl -= vmass * 60;

   190

			}

   191

		}

   192

	}

   193

   194

   195

	// these are shown in the UI

   196

	v->u.rail.cached_weight = mass;

   197

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

   198

	v->max_speed = max_speed;

   199

   200

   201

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

   202

		resistance = 13 * mass / 10;

   203

		resistance += 60 * num;

   204

		resistance += friction * mass * speed / 1000;

   205

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

   206

	} else

   207

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

   208

	resistance += incl;

   209

	resistance *= 4; //[N]

   210

   211

	if (speed > 0) {

   212

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

   213

			case 0:

   214

			case 1:

   215

				force = power / speed; //[N]

   216

				force *= 22;

   217

				force /= 10;

   218

				break;

   219

   220

			case 2:

   221

				force = power / 25;

   222

				break;

   223

		}

   224

	} else {

   225

		//"kickoff" acceleration

   226

		force = resistance * 10;

   227

	}

   228

   229

	if (force <= 0) force = 10000;

   230

   231

	if (v->u.rail.railtype != 2) force = min(force, mass * 10 * 200);

   232

   233

	if (mode == AM_ACCEL) {

   234

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

   235

	} else {

   236

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

   237

	}

   238

}

   239

   240

void UpdateTrainAcceleration(Vehicle *v)

   241

{

   242

	uint power = 0;

   243

	uint max_speed = 5000;

   244

	uint weight = 0;

   245

	Vehicle *u = v;

   246

   247

	assert(v->subtype == TS_Front_Engine);

   248

   249

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

   250

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

   251

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

   252

   253

		// power is sum of the power for all engines

   254

		power += rvi->power;

   255

   256

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

   257

		if (rvi->max_speed != 0 && rvi->max_speed <= max_speed)

   258

			max_speed = rvi->max_speed;

   259

   260

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

   261

		weight += rvi->weight;

   262

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

   263

	}

   264

   265

	// these are shown in the UI

   266

	v->u.rail.cached_weight = weight;

   267

	v->u.rail.cached_power = power;

   268

	v->max_speed = max_speed;

   269

   270

	assert(weight != 0);

   271

   272

	v->acceleration = clamp(power / weight * 4, 1, 255);

   273

}

   274

   275

int GetTrainImage(const Vehicle *v, byte direction)

   276

{

   277

	int img = v->spritenum;

   278

	int base;

   279

   280

	if (is_custom_sprite(img)) {

   281

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

   282

		if (base != 0) return base;

   283

		img = _engine_original_sprites[v->engine_type];

   284

	}

   285

   286

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

   287

   288

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

   289

		base += _wagon_full_adder[img];

   290

	return base;

   291

}

   292

   293

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

   294

{

   295

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   296

   297

	int img = rvi->image_index;

   298

	uint32 image = 0;

   299

   300

	if (is_custom_sprite(img)) {

   301

		image = GetCustomVehicleIcon(engine, 6);

   302

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

   303

	}

   304

	if (image == 0) {

   305

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

   306

	}

   307

   308

	if (rvi->flags & RVI_MULTIHEAD) {

   309

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

   310

		x += 15;

   311

		image = 0;

   312

		if (is_custom_sprite(img)) {

   313

			image = GetCustomVehicleIcon(engine, 2);

   314

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

   315

		}

   316

		if (image == 0) {

   317

			image =

   318

				((6 + _engine_sprite_add[img + 1]) & _engine_sprite_and[img + 1]) +

   319

				_engine_sprite_base[img + 1];

   320

		}

   321

	}

   322

	DrawSprite(image | image_ormod, x, y);

   323

}

   324

   325

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

   326

{

   327

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   328

	int cap;

   329

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

   330

   331

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

   332

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

   333

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

   334

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

   335

   336

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

   337

   338

	cap = rvi->capacity;

   339

	SetDParam(5, STR_8838_N_A);

   340

	if (cap != 0) {

   341

		SetDParam(6, cap << multihead);

   342

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

   343

	}

   344

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   345

}

   346

   347

   348

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

   349

{

   350

	int32 value;

   351

	Vehicle *v;

   352

	const RailVehicleInfo *rvi;

   353

	int dir;

   354

	const Engine *e;

   355

	int x,y;

   356

   357

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   358

   359

	rvi = RailVehInfo(engine);

   360

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

   361

   362

	if (!(flags & DC_QUERY_COST)) {

   363

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   364

   365

		v = AllocateVehicle();

   366

		if (v == NULL)

   367

			return CMD_ERROR;

   368

   369

		if (flags & DC_EXEC) {

   370

			byte img = rvi->image_index;

   371

			Vehicle *u, *w;

   372

   373

			v->spritenum = img;

   374

   375

			u = NULL;

   376

   377

			FOR_ALL_VEHICLES(w) {

   378

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

   379

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

   380

					u = GetLastVehicleInChain(w);

   381

					break;

   382

				}

   383

			}

   384

   385

			v->engine_type = engine;

   386

   387

			dir = _map5[tile] & 3;

   388

   389

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

   390

			v->tile = (TileIndex)tile;

   391

   392

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

   393

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

   394

   395

			v->x_pos = x;

   396

			v->y_pos = y;

   397

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

   398

			v->owner = _current_player;

   399

			v->z_height = 6;

   400

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

   401

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   402

   403

			v->subtype = TS_Free_Car;

   404

			if (u != NULL) {

   405

				u->next = v;

   406

				v->subtype = TS_Not_First;

   407

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

   408

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

   409

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

   410

			} else {

   411

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

   412

			}

   413

   414

			v->cargo_type = rvi->cargo_type;

   415

			v->cargo_cap = rvi->capacity;

   416

			v->value = value;

   417

//			v->day_counter = 0;

   418

   419

			e = &_engines[engine];

   420

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

   421

   422

			v->build_year = _cur_year;

   423

			v->type = VEH_Train;

   424

			v->cur_image = 0xAC2;

   425

   426

			_new_wagon_id = v->index;

   427

   428

			VehiclePositionChanged(v);

   429

   430

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   431

		}

   432

	}

   433

   434

	return value;

   435

}

   436

   437

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

   438

static void NormalizeTrainVehInDepot(Vehicle *u)

   439

{

   440

	Vehicle *v;

   441

   442

	FOR_ALL_VEHICLES(v) {

   443

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

   444

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

   445

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

   446

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

   447

					CMD_MOVE_RAIL_VEHICLE) == CMD_ERROR)

   448

				break;

   449

		}

   450

	}

   451

}

   452

   453

static const byte _railveh_unk1[] = {

   454

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

   455

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

   456

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

   457

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

   461

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

   462

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

   463

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

   467

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

   468

	0, 0, 0, 0,

   469

};

   470

   471

static const byte _railveh_score[] = {

   472

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

   473

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

   474

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

   475

	41, 51, 52, 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, 60, 62,

   479

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

   480

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

   481

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

   482

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

   483

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

   484

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

   485

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

   486

	0, 0, 0, 0,

   487

};

   488

   489

   490

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   491

{

   492

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

   493

}

   494

   495

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

   496

{

   497

	u->direction = v->direction;

   498

	u->owner = v->owner;

   499

	u->tile = v->tile;

   500

	u->x_pos = v->x_pos;

   501

	u->y_pos = v->y_pos;