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) \

    23

		? is_custom_firsthead_sprite(spritenum) \

    24

		: _engine_sprite_add[spritenum] == 0)

    25

    26

static bool TrainCheckIfLineEnds(Vehicle *v);

    27

    28

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

    29

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

    30

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

    31

    32

    33

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

    34

 * be interpreted? */

    35

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

    36

	{7, 1},

    37

	{0, 2},

    38

	{1, 3},

    39

	{2, 4},

    40

	{3, 5},

    41

	{4, 6},

    42

	{5, 7},

    43

	{6, 0},

    44

};

    45

    46

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

    47

	{6, 2},

    48

	{7, 3},

    49

	{0, 4},

    50

	{1, 5},

    51

	{2, 6},

    52

	{3, 7},

    53

	{4, 0},

    54

	{5, 1},

    55

};

    56

    57

enum AccelType {

    58

	AM_ACCEL,

    59

	AM_BRAKE

    60

};

    61

    62

static bool TrainShouldStop(Vehicle *v, TileIndex tile)

    63

{

    64

	Order *o = &v->current_order;

    65

	assert(v->type == VEH_Train);

    66

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

    67

	//When does a train drive through a station

    68

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

    69

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

    70

			_map2[tile] == o->station )

    71

		return false;

    72

    73

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

    74

		return false;

    75

    76

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

    77

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

    78

		return false;

    79

    80

	return true;

    81

}

    82

    83

//new acceleration

    84

static int GetTrainAcceleration(Vehicle *v, bool mode)

    85

{

    86

	const Vehicle *u;

    87

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

    88

	int power = 0;

    89

	int mass = 0;

    90

	int max_speed = 2000;

    91

	int area = 120;

    92

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

    93

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

    94

	int incl = 0;

    95

	int resistance;

    96

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

    97

	int force = 0x3FFFFFFF;

    98

	int pos = 0;

    99

	int lastpos = -1;

   100

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

   101

	int sum = 0;

   102

	int numcurve = 0;

   103

   104

	speed *= 10;

   105

	speed /= 16;

   106

   107

	//first find the curve speed limit

   108

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

   109

		int dir = u->direction;

   110

		int ndir = u->next->direction;

   111

		int i;

   112

   113

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

   114

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

   115

				curvecount[i]++;

   116

				if (lastpos != -1) {

   117

					numcurve++;

   118

					sum += pos - lastpos;

   119

					if (pos - lastpos == 1) {

   120

						max_speed = 88;

   121

					}

   122

				}

   123

				lastpos = pos;

   124

			}

   125

		}

   126

   127

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

   128

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

   129

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

   130

			max_speed = 61;

   131

		}

   132

	}

   133

   134

	if (numcurve > 0) sum /= numcurve;

   135

   136

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

   137

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

   138

   139

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

   140

			max_speed = 0xFFFF;

   141

		} else if (total > 1) {

   142

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

   143

		}

   144

	}

   145

   146

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

   147

   148

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

   149

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

   150

			int station_length = 0;

   151

			TileIndex tile = v->tile;

   152

			int delta_v;

   153

   154

			max_speed = 120;

   155

			do {

   156

				station_length++;

   157

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

   158

			} while (IsCompatibleTrainStationTile(tile, v->tile));

   159

   160

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

   161

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

   162

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

   163

   164

			max_speed = max(max_speed, 25 * station_length);

   165

		}

   166

	}

   167

   168

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

   169

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

   170

		int vmass;

   171

   172

		num++;

   173

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

   174

		drag_coeff += 3;

   175

   176

		if (rvi->max_speed != 0)

   177

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

   178

   179

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

   180

			max_speed = 61;

   181

   182

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

   183

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

   184

		mass += vmass; //[t]

   185

   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

	// these are shown in the UI

   195

	v->u.rail.cached_weight = mass;

   196

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

   197

	v->max_speed = max_speed;

   198

   199

   200

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

   201

		resistance = 13 * mass / 10;

   202

		resistance += 60 * num;

   203

		resistance += friction * mass * speed / 1000;

   204

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

   205

	} else

   206

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

   207

	resistance += incl;

   208

	resistance *= 4; //[N]

   209

   210

	if (speed > 0) {

   211

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

   212

			case 0:

   213

			case 1:

   214

				force = power / speed; //[N]

   215

				force *= 22;

   216

				force /= 10;

   217

				break;

   218

   219

			case 2:

   220

				force = power / 25;

   221

				break;

   222

		}

   223

	} else {

   224

		//"kickoff" acceleration

   225

		force = resistance * 10;

   226

	}

   227

   228

	if (force <= 0) force = 10000;

   229

   230

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

   231

   232

	if (mode == AM_ACCEL) {

   233

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

   234

	} else {

   235

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

   236

	}

   237

}

   238

   239

void UpdateTrainAcceleration(Vehicle *v)

   240

{

   241

	uint power = 0;

   242

	uint max_speed = 5000;

   243

	uint weight = 0;

   244

	Vehicle *u = v;

   245

   246

	assert(v->subtype == TS_Front_Engine);

   247

   248

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

   249

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

   250

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

   251

   252

		// power is sum of the power for all engines

   253

		power += rvi->power;

   254

   255

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

   256

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

   257

			max_speed = rvi->max_speed;

   258

   259

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

   260

		weight += rvi->weight;

   261

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

   262

	}

   263

   264

	// these are shown in the UI

   265

	v->u.rail.cached_weight = weight;

   266

	v->u.rail.cached_power = power;

   267

	v->max_speed = max_speed;

   268

   269

	assert(weight != 0);

   270

   271

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

   272

}

   273

   274

int GetTrainImage(const Vehicle *v, byte direction)

   275

{

   276

	int img = v->spritenum;

   277

	int base;

   278

   279

	if (is_custom_sprite(img)) {

   280

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

   281

		if (base != 0) return base;

   282

		img = _engine_original_sprites[v->engine_type];

   283

	}

   284

   285

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

   286

   287

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

   288

		base += _wagon_full_adder[img];

   289

	return base;

   290

}

   291

   292

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

   293

{

   294

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   295

   296

	int img = rvi->image_index;

   297

	uint32 image = 0;

   298

   299

	if (is_custom_sprite(img)) {

   300

		image = GetCustomVehicleIcon(engine, 6);

   301

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

   302

	}

   303

	if (image == 0) {

   304

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

   305

	}

   306

   307

	if (rvi->flags & RVI_MULTIHEAD) {

   308

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

   309

		x += 15;

   310

		image = 0;

   311

		if (is_custom_sprite(img)) {

   312

			image = GetCustomVehicleIcon(engine, 2);

   313

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

   314

		}

   315

		if (image == 0) {

   316

			image =

   317

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

   318

				_engine_sprite_base[img + 1];

   319

		}

   320

	}

   321

	DrawSprite(image | image_ormod, x, y);

   322

}

   323

   324

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

   325

{

   326

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   327

	int cap;

   328

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

   329

   330

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

   331

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

   332

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

   333

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

   334

   335

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

   336

   337

	cap = rvi->capacity;

   338

	SetDParam(5, STR_8838_N_A);

   339

	if (cap != 0) {

   340

		SetDParam(6, cap << multihead);

   341

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

   342

	}

   343

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   344

}

   345

   346

   347

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

   348

{

   349

	int32 value;

   350

	Vehicle *v;

   351

	const RailVehicleInfo *rvi;

   352

	int dir;

   353

	const Engine *e;

   354

	int x,y;

   355

   356

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   357

   358

	rvi = RailVehInfo(engine);

   359

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

   360

   361

	if (!(flags & DC_QUERY_COST)) {

   362

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   363

   364

		v = AllocateVehicle();

   365

		if (v == NULL)

   366

			return CMD_ERROR;

   367

   368

		if (flags & DC_EXEC) {

   369

			byte img = rvi->image_index;

   370

			Vehicle *u, *w;

   371

   372

			v->spritenum = img;

   373

   374

			u = NULL;

   375

   376

			FOR_ALL_VEHICLES(w) {

   377

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

   378

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

   379

					u = GetLastVehicleInChain(w);

   380

					break;

   381

				}

   382

			}

   383

   384

			v->engine_type = engine;

   385

   386

			dir = _map5[tile] & 3;

   387

   388

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

   389

			v->tile = (TileIndex)tile;

   390

   391

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

   392

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

   393

   394

			v->x_pos = x;

   395

			v->y_pos = y;

   396

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

   397

			v->owner = _current_player;

   398

			v->z_height = 6;

   399

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

   400

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   401

   402

			v->subtype = TS_Free_Car;

   403

			if (u != NULL) {

   404

				u->next = v;

   405

				v->subtype = TS_Not_First;

   406

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

   407

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

   408

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

   409

			} else {

   410

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

   411

			}

   412

   413

			v->cargo_type = rvi->cargo_type;

   414

			v->cargo_cap = rvi->capacity;

   415

			v->value = value;

   416

//			v->day_counter = 0;

   417

   418

			e = &_engines[engine];

   419

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

   420

   421

			v->build_year = _cur_year;

   422

			v->type = VEH_Train;

   423

			v->cur_image = 0xAC2;

   424

   425

			_new_wagon_id = v->index;

   426

   427

			VehiclePositionChanged(v);

   428

   429

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   430

		}

   431

	}

   432

   433

	return value;

   434

}

   435

   436

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

   437

static void NormalizeTrainVehInDepot(Vehicle *u)

   438

{

   439

	Vehicle *v;

   440

   441

	FOR_ALL_VEHICLES(v) {

   442

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

   443

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

   444

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

   445

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

   446

					CMD_MOVE_RAIL_VEHICLE) == CMD_ERROR)

   447

				break;

   448

		}

   449

	}

   450

}

   451

   452

static const byte _railveh_unk1[] = {

   453

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

   454

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

   455

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

   456

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

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

   467

	0, 0, 0, 0,

   468

};

   469

   470

static const byte _railveh_score[] = {

   471

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

   472

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

   473

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

   474

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

   478

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

   479

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

   480

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

   481

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

   482

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

   483

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

   484

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

   485

	0, 0, 0, 0,

   486

};

   487

   488

   489

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   490

{

   491

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

   492

}

   493

   494

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

   495

{

   496

	u->direction = v->direction;

   497

	u->owner = v->owner;

   498

	u->tile = v->tile;

   499

	u->x_pos = v->x_pos;

   500

	u->y_pos = v->y_pos;

   501

	u->z_pos = v->z_pos;