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 &&

    68

			_map2[tile] == o->station )

    69

		return false;

    70

    71

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

    72

		return false;

    73

    74

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

    75

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

    76

		return false;

    77

    78

	return true;

    79

}

    80

    81

//new acceleration

    82

static int GetTrainAcceleration(Vehicle *v, bool mode)

    83

{

    85

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

    86

	int power = 0;

    87

	int mass = 0;

    88

	int max_speed = 2000;

    89

	int area = 120;

    90

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

    91

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

    92

	int incl = 0;

    93

	int resistance;

    94

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

    95

	int force = 0x3FFFFFFF;

    96

	int pos = 0;

    97

	int lastpos = -1;

    98

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

    99

	int sum = 0;

   100

	int numcurve = 0;

   101

   102

	speed *= 10;

   103

	speed /= 16;

   104

   105

	//first find the curve speed limit

   107

		int dir = u->direction;

   108

		int ndir = u->next->direction;

   110

   111

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

   112

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

   113

				curvecount[i]++;

   114

				if (lastpos != -1) {

   117

					if (pos - lastpos == 1) {

   118

						max_speed = 88;

   119

					}

   120

				}

   121

				lastpos = pos;

   122

			}

   123

		}

   124

   125

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

   126

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

   127

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

   128

			max_speed = 61;

   129

		}

   130

	}

   131

   132

	if (numcurve > 0) sum /= numcurve;

   133

   134

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

   135

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

   136

   137

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

   138

			max_speed = 0xFFFF;

   139

		} else if (total > 1) {

   140

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

   141

		}

   142

	}

   143

   144

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

   145

   146

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

   147

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

   148

			int station_length = 0;

   149

			TileIndex tile = v->tile;

   150

			int delta_v;

   151

   152

			max_speed = 120;

   153

			do {

   154

				station_length++;

   156

			} while (IsTileType(tile, MP_STATION));

   157

   158

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

   159

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

   160

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

   161

   162

			max_speed = max(max_speed, 25 * station_length);

   163

		}

   164

	}

   165

   166

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

   167

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

   168

		int vmass;

   169

   170

		num++;

   171

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

   172

		drag_coeff += 3;

   173

   174

		if (rvi->max_speed != 0)

   175

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

   176

   177

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

   178

			max_speed = 61;

   179

   180

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

   181

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

   182

		mass += vmass; //[t]

   183

   184

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

   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

   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;