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

#include "vehicle_gui.h"

    20

    21

#define IS_FIRSTHEAD_SPRITE(spritenum) \

    22

	(is_custom_sprite(spritenum) ? IS_CUSTOM_FIRSTHEAD_SPRITE(spritenum) : _engine_sprite_add[spritenum] == 0)

    23

    24

static bool TrainCheckIfLineEnds(Vehicle *v);

    25

extern void ShowTrainViewWindow(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 (IsCompatibleTrainStationTile(tile, v->tile));

   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 (HASBIT(u->u.rail.flags, VRF_GOINGUP)) {

   186

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

   187

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

   188

			incl -= vmass * 60;

   189

		}

   190

	}

   191

   192

   193

	// these are shown in the UI

   194

	v->u.rail.cached_weight = mass;

   195

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

   196

	v->max_speed = max_speed;

   197

   198

   199

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

   200

		resistance = 13 * mass / 10;

   201

		resistance += 60 * num;

   202

		resistance += friction * mass * speed / 1000;

   203

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

   204

	} else

   205

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

   206

	resistance += incl;

   207

	resistance *= 4; //[N]

   208

   209

	if (speed > 0) {

   210

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

   211

			case 0:

   212

			case 1:

   213

				force = power / speed; //[N]

   214

				force *= 22;

   215

				force /= 10;

   216

				break;

   217

   218

			case 2:

   219

				force = power / 25;

   220

				break;

   221

		}

   222

	} else {

   223

		//"kickoff" acceleration

   224

		force = resistance * 10;

   225

	}

   226

   227

	if (force <= 0) force = 10000;

   228

   229

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

   230

   231

	if (mode == AM_ACCEL) {

   232

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

   233

	} else {

   234

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

   235

	}

   236

}

   237

   238

void UpdateTrainAcceleration(Vehicle *v)

   239

{

   240

	uint power = 0;

   241

	uint max_speed = 5000;

   242

	uint weight = 0;

   243

	Vehicle *u = v;

   244

   245

	assert(v->subtype == TS_Front_Engine);

   246

   247

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

   248

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

   249

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

   250

   251

		// power is sum of the power for all engines

   252

		power += rvi->power;

   253

   254

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

   255

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

   256

			max_speed = rvi->max_speed;

   257

   258

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

   259

		weight += rvi->weight;

   260

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

   261

	}

   262

   263

	// these are shown in the UI

   264

	v->u.rail.cached_weight = weight;

   265

	v->u.rail.cached_power = power;

   266

	v->max_speed = max_speed;

   267

   268

	assert(weight != 0);

   269

   270

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

   271

}

   272

   273

int GetTrainImage(const Vehicle *v, byte direction)

   274

{

   275

	int img = v->spritenum;

   276

	int base;

   277

   278

	if (is_custom_sprite(img)) {

   279

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

   280

		if (base != 0) return base;

   281

		img = _engine_original_sprites[v->engine_type];

   282

	}

   283

   284

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

   285

   286

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

   287

		base += _wagon_full_adder[img];

   288

	return base;

   289

}

   290

   291

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

   292

{

   293

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   294

   295

	int img = rvi->image_index;

   296

	uint32 image = 0;

   297

   298

	if (is_custom_sprite(img)) {

   299

		image = GetCustomVehicleIcon(engine, 6);

   300

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

   301

	}

   302

	if (image == 0) {

   303

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

   304

	}

   305

   306

	if (rvi->flags & RVI_MULTIHEAD) {

   307

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

   308

		x += 15;

   309

		image = 0;

   310

		if (is_custom_sprite(img)) {

   311

			image = GetCustomVehicleIcon(engine, 2);

   312

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

   313

		}

   314

		if (image == 0) {

   315

			image =

   316

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

   317

				_engine_sprite_base[img + 1];

   318

		}

   319

	}

   320

	DrawSprite(image | image_ormod, x, y);

   321

}

   322

   323

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

   324

{

   325

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   326

	int cap;

   327

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

   328

   329

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

   330

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

   331

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

   332

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

   333

   334

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

   335

   336

	cap = rvi->capacity;

   337

	SetDParam(5, STR_8838_N_A);

   338

	if (cap != 0) {

   339

		SetDParam(6, cap << multihead);

   340

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

   341

	}

   342

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   343

}

   344

   345

   346

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

   347

{

   348

	int32 value;

   349

	Vehicle *v;

   350

	const RailVehicleInfo *rvi;

   351

	int dir;

   352

	const Engine *e;

   353

	int x,y;

   354

   355

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   356

   357

	rvi = RailVehInfo(engine);

   358

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

   359

   360

	if (!(flags & DC_QUERY_COST)) {

   361

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   362

   363

		v = AllocateVehicle();

   364

		if (v == NULL)

   365

			return CMD_ERROR;

   366

   367

		if (flags & DC_EXEC) {

   368

			byte img = rvi->image_index;

   369

			Vehicle *u, *w;

   370

   371

			v->spritenum = img;

   372

   373

			u = NULL;

   374

   375

			FOR_ALL_VEHICLES(w) {

   376

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

   377

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

   378

					u = GetLastVehicleInChain(w);

   379

					break;

   380

				}

   381

			}

   382

   383

			v->engine_type = engine;

   384

   385

			dir = _map5[tile] & 3;

   386

   387

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

   388

			v->tile = (TileIndex)tile;

   389

   390

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

   391

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

   392

   393

			v->x_pos = x;

   394

			v->y_pos = y;

   395

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

   396

			v->owner = _current_player;

   397

			v->z_height = 6;

   398

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

   399

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   400

   401

			v->subtype = TS_Free_Car;

   402

			if (u != NULL) {

   403

				u->next = v;

   404

				v->subtype = TS_Not_First;

   405

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

   406

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

   407

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

   408

			} else {

   409

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

   410

			}

   411

   412

			v->cargo_type = rvi->cargo_type;

   413

			v->cargo_cap = rvi->capacity;

   414

			v->value = value;

   415

//			v->day_counter = 0;

   416

   417

			e = &_engines[engine];

   418

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

   419

   420

			v->build_year = _cur_year;

   421

			v->type = VEH_Train;

   422

			v->cur_image = 0xAC2;

   423

   424

			_new_wagon_id = v->index;

   425

   426

			VehiclePositionChanged(v);

   427

   428

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   429

		}

   430

	}

   431

   432

	return value;

   433

}

   434

   435

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

   436

static void NormalizeTrainVehInDepot(Vehicle *u)

   437

{

   438

	Vehicle *v;

   439

   440

	FOR_ALL_VEHICLES(v) {

   441

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

   442

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

   443

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

   444

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

   445

					CMD_MOVE_RAIL_VEHICLE) == CMD_ERROR)

   446

				break;

   447

		}

   448

	}

   449

}

   450

   451

static const byte _railveh_unk1[] = {

   452

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

   453

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

   454

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

   455

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

   459

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

   460

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

   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,

   467

};

   468

   469

static const byte _railveh_score[] = {

   470

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

   471

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

   472

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

   473

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

   477

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

   478

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

   479

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

   480

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

   481

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

   485

};

   486

   487

   488

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   489

{

   490

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

   491

}

   492

   493

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

   494

{

   495

	u->direction = v->direction;

   496

	u->owner = v->owner;

   497

	u->tile = v->tile;

   498

	u->x_pos = v->x_pos;

   499

	u->y_pos = v->y_pos;

   500

	u->z_pos = v->z_pos;

   501