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

{

    84

	Vehicle *u = v;

    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 *dist = NULL;

   100

	int sum = 0;

   101

	int numcurve = 0;

   102

	int i;

   103

   104

	speed *= 10;

   105

	speed /= 16;

   106

   107

	//first find the curve speed limit

   108

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

   109

		int dir = u->direction;

   110

		int ndir = u->next->direction;

   111

   112

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

   113

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

   114

				curvecount[i]++;

   115

				if (lastpos != -1) {

   116

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

   117

					dist[numcurve - 1] = 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

	for (i = 0; i < numcurve; i++) sum += dist[i];

   134

   135

	free(dist);

   136

	dist = NULL;

   137

   138

	if (numcurve > 0) sum /= numcurve;

   139

   140

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

   141

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

   142

   143

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

   144

			max_speed = 0xFFFF;

   145

		} else if (total > 1) {

   146

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

   147

		}

   148

	}

   149

   150

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

   151

   152

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

   153

		static const TileIndexDiffC _station_dir_from_vdir[] = {

   154

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

   155

		};

   156

   157

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

   158

			int station_length = 0;

   159

			TileIndex tile = v->tile;

   160

			int delta_v;

   161

   162

			max_speed = 120;

   163

			do {

   164

				station_length++;

   165

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

   166

			} while (IsTileType(tile, MP_STATION));

   167

   168

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

   169

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

   170

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

   171

   172

			max_speed = max(max_speed, 25 * station_length);

   173

		}

   174

	}

   175

   176

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

   177

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

   178

		int vmass;

   179

   180

		num++;

   181

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

   182

		drag_coeff += 3;

   183

   184

		if (rvi->max_speed != 0)

   185

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

   186

   187

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

   188

			max_speed = 61;

   189

   190

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

   191

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

   192

		mass += vmass; //[t]

   193

   194

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

   195

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

   196

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

   197

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

   198

				incl -= vmass * 60;

   199

			}

   200

		}

   201

	}

   202

   203

   204

	// these are shown in the UI

   205

	v->u.rail.cached_weight = mass;

   206

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

   207

	v->max_speed = max_speed;

   208

   209

   210

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

   211

		resistance = 13 * mass / 10;

   212

		resistance += 60 * num;

   213

		resistance += friction * mass * speed / 1000;

   214

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

   215

	} else

   216

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

   217

	resistance += incl;

   218

	resistance *= 4; //[N]

   219

   220

	if (speed > 0) {

   221

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

   222

			case 0:

   223

			case 1:

   224

				force = power / speed; //[N]

   225

				force *= 22;

   226

				force /= 10;

   227

				break;

   228

   229

			case 2:

   230

				force = power / 25;

   231

				break;

   232

		}

   233

	} else {

   234

		//"kickoff" acceleration

   235

		force = resistance * 10;

   236

	}

   237

   238

	if (force <= 0) force = 10000;

   239

   240

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

   241

   242

	if (mode == AM_ACCEL) {

   243

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

   244

	} else {

   245

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

   246

	}

   247

}

   248

   249

void UpdateTrainAcceleration(Vehicle *v)

   250

{

   251

	uint power = 0;

   252

	uint max_speed = 5000;

   253

	uint weight = 0;

   254

	Vehicle *u = v;

   255

   256

	assert(v->subtype == TS_Front_Engine);

   257

   258

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

   259

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

   260

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

   261

   262

		// power is sum of the power for all engines

   263

		power += rvi->power;

   264

   265

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

   266

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

   267

			max_speed = rvi->max_speed;

   268

   269

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

   270

		weight += rvi->weight;

   271

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

   272

	}

   273

   274

	// these are shown in the UI

   275

	v->u.rail.cached_weight = weight;

   276

	v->u.rail.cached_power = power;

   277

	v->max_speed = max_speed;

   278

   279

	assert(weight != 0);

   280

   281

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

   282

}

   283

   284

int GetTrainImage(const Vehicle *v, byte direction)

   285

{

   286

	int img = v->spritenum;

   287

	int base;

   288

   289

	if (is_custom_sprite(img)) {

   290

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

   291

		if (base != 0) return base;

   292

		img = _engine_original_sprites[v->engine_type];

   293

	}

   294

   295

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

   296

   297

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

   298

		base += _wagon_full_adder[img];

   299

	return base;

   300

}

   301

   302

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

   303

{

   304

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   305

   306

	int img = rvi->image_index;

   307

	uint32 image = 0;

   308

   309

	if (is_custom_sprite(img)) {

   310

		image = GetCustomVehicleIcon(engine, 6);

   311

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

   312

	}

   313

	if (image == 0) {

   314

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

   315

	}

   316

   317

	if (rvi->flags & RVI_MULTIHEAD) {

   318

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

   319

		x += 15;

   320

		image = 0;

   321

		if (is_custom_sprite(img)) {

   322

			image = GetCustomVehicleIcon(engine, 2);

   323

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

   324

		}

   325

		if (image == 0) {

   326

			image =

   327

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

   328

				_engine_sprite_base[img + 1];

   329

		}

   330

	}

   331

	DrawSprite(image | image_ormod, x, y);

   332

}

   333

   334

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

   335

{

   336

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   337

	int cap;

   338

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

   339

   340

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

   341

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

   342

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

   343

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

   344

   345

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

   346

   347

	cap = rvi->capacity;

   348

	SetDParam(5, STR_8838_N_A);

   349

	if (cap != 0) {

   350

		SetDParam(6, cap << multihead);

   351

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

   352

	}

   353

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   354

}

   355

   356

   357

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

   358

{

   359

	int32 value;

   360

	Vehicle *v;

   361

	const RailVehicleInfo *rvi;

   362

	int dir;

   363

	const Engine *e;

   364

	int x,y;

   365

   366

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   367

   368

	rvi = RailVehInfo(engine);

   369

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

   370

   371

	if (!(flags & DC_QUERY_COST)) {

   372

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   373

   374

		v = AllocateVehicle();

   375

		if (v == NULL)

   376

			return CMD_ERROR;

   377

   378

		if (flags & DC_EXEC) {

   379

			byte img = rvi->image_index;

   380

			Vehicle *u, *w;

   381

   382

			v->spritenum = img;

   383

   384

			u = NULL;

   385

   386

			FOR_ALL_VEHICLES(w) {

   387

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

   388

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

   389

					u = GetLastVehicleInChain(w);

   390

					break;

   391

				}

   392

			}

   393

   394

			v->engine_type = engine;

   395

   396

			dir = _map5[tile] & 3;

   397

   398

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

   399

			v->tile = (TileIndex)tile;

   400

   401

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

   402

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

   403

   404

			v->x_pos = x;

   405

			v->y_pos = y;

   406

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

   407

			v->owner = _current_player;

   408

			v->z_height = 6;

   409

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

   410

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   411

   412

			v->subtype = TS_Free_Car;

   413

			if (u != NULL) {

   414

				u->next = v;

   415

				v->subtype = TS_Not_First;

   416

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

   417

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

   418

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

   419

			} else {

   420

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

   421

			}

   422

   423

			v->cargo_type = rvi->cargo_type;

   424

			v->cargo_cap = rvi->capacity;

   425

			v->value = value;

   426

//			v->day_counter = 0;

   427

   428

			e = &_engines[engine];

   429

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

   430

   431

			v->build_year = _cur_year;

   432

			v->type = VEH_Train;

   433

			v->cur_image = 0xAC2;

   434

   435

			_new_wagon_id = v->index;

   436

   437

			VehiclePositionChanged(v);

   438

   439

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   440

		}

   441

	}

   442

   443

	return value;

   444

}

   445

   446

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

   447

static void NormalizeTrainVehInDepot(Vehicle *u)

   448

{

   449

	Vehicle *v;

   450

   451

	FOR_ALL_VEHICLES(v) {

   452

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

   453

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

   454

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

   455

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

   456

					CMD_MOVE_RAIL_VEHICLE) == CMD_ERROR)

   457

				break;

   458

		}

   459

	}

   460

}

   461

   462

static const byte _railveh_unk1[] = {

   463

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

   464

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

   465

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

   466

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

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

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

   478

};

   479

   480

static const byte _railveh_score[] = {

   481

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

   482

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

   483

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

   484

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

   485

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

   486

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

   487

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

   488

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

   489

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

   490

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

   491

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

   492

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

   493

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

   494

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

   495

	0, 0, 0, 0,

   496

};

   497

   498

   499

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   500

{

   501

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

   502

}