1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "vehicle.h"

     6

#include "command.h"

     7

#include "pathfind.h"

     8

#include "station.h"

     9

#include "table/train_cmd.h"

    10

#include "gfx.h"

    11

#include "news.h"

    12

#include "engine.h"

    13

#include "player.h"

    14

#include "sound.h"

    15

    16

#define is_firsthead_sprite(spritenum) \

    17

	(is_custom_sprite(spritenum) \

    18

		? is_custom_firsthead_sprite(spritenum) \

    19

		: _engine_sprite_add[spritenum] == 0)

    20

    21

static bool TrainCheckIfLineEnds(Vehicle *v);

    22

    23

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

    24

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

    25

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

    26

    27

static const byte _signal_onedir[14] = {

    28

	0x80, 0x80, 0x80, 0x20, 0x40, 0x10, 0, 0,

    29

	0x40, 0x40, 0x40, 0x10, 0x80, 0x20

    30

};

    31

    32

static const byte _signal_otherdir[14] = {

    33

	0x40, 0x40, 0x40, 0x10, 0x80, 0x20, 0, 0,

    34

	0x80, 0x80, 0x80, 0x20, 0x40, 0x10

    35

};

    36

    37

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

    38

	{7, 1},

    39

	{0, 2},

    40

	{1, 3},

    41

	{2, 4},

    42

	{3, 5},

    43

	{4, 6},

    44

	{5, 7},

    45

	{6, 0},

    46

};

    47

    48

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

    49

	{6, 2},

    50

	{7, 3},

    51

	{0, 4},

    52

	{1, 5},

    53

	{2, 6},

    54

	{3, 7},

    55

	{4, 0},

    56

	{5, 1},

    57

};

    58

    59

enum AccelType {

    60

	AM_ACCEL,

    61

	AM_BRAKE

    62

};

    63

    64

//new acceleration

    65

static int GetTrainAcceleration(Vehicle *v, bool mode)

    66

{

    67

	Vehicle *u = v;

    68

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

    69

	int power = 0;

    70

	int mass = 0;

    71

	int max_speed = 2000;

    72

	int area = 120;

    73

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

    74

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

    75

	int incl = 0;

    76

	int resistance;

    77

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

    78

	int force = 0x3FFFFFFF;

    79

	int pos = 0;

    80

	int lastpos = -1;

    81

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

    82

	int *dist = NULL;

    83

	int sum = 0;

    84

	int numcurve = 0;

    85

	int i;

    86

    87

	speed *= 10;

    88

	speed /= 16;

    89

    90

	//first find the curve speed limit

    91

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

    92

		int dir = u->direction;

    93

		int ndir = u->next->direction;

    94

    95

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

    96

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

    97

				curvecount[i]++;

    98

				if (lastpos != -1) {

    99

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

   100

					dist[numcurve - 1] = pos - lastpos;

   101

					if (pos - lastpos == 1) {

   102

						max_speed = 88;

   103

					}

   104

				}

   105

				lastpos = pos;

   106

			}

   107

		}

   108

   109

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

   110

		if ( _curve_neighbours90[dir][0] == ndir || _curve_neighbours90[dir][1] == ndir) {

   111

			max_speed = 61;

   112

		}

   113

	}

   114

   115

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

   116

		sum += dist[i];

   117

	}

   118

   119

	if (numcurve > 0) {

   120

		sum /= numcurve;

   121

	}

   122

   123

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

   124

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

   125

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

   126

			max_speed = 0xFFFF;

   127

		} else if (total > 1) {

   128

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

   129

		}

   130

	}

   131

   132

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

   133

   134

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

   135

		static const TileIndexDiffC _station_dir_from_vdir[] = {

   136

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

   137

		};

   138

   139

		if (((v->current_order.station == _map2[v->tile]) || !(v->current_order.flags & OF_NON_STOP)) && v->last_station_visited != _map2[v->tile]) {

   140

			int station_length = 0;

   141

			TileIndex tile = v->tile;

   142

			int delta_v;

   143

   144

			max_speed = 120;

   145

			do {

   146

				station_length++;

   147

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

   148

			} while (IsTileType(tile, MP_STATION));

   149

   150

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

   151

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

   152

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

   153

   154

			max_speed = max(max_speed, 25 * station_length);

   155

		}

   156

	}

   157

   158

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

   159

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

   160

		int vmass;

   161

   162

		num++;

   163

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

   164

		drag_coeff += 3;

   165

   166

		if (rvi->max_speed != 0)

   167

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

   168

   169

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

   170

			max_speed = 61;

   171

   172

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

   173

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

   174

		mass += vmass; //[t]

   175

   176

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

   177

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

   178

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

   179

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

   180

				incl -= vmass * 60;

   181

			}

   182

		}

   183

	}

   184

   185

   186

	// these are shown in the UI

   187

	v->u.rail.cached_weight = mass;

   188

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

   189

	v->max_speed = max_speed;

   190

   191

   192

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

   193

		resistance = 13 * mass / 10;

   194

		resistance += 60 * num;

   195

		resistance += friction * mass * speed / 1000;

   196

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

   197

	} else

   198

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

   199

	resistance += incl;

   200

	resistance *= 4; //[N]

   201

   202

	if (speed > 0) {

   203

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

   204

			case 0:

   205

			case 1:

   206

			{

   207

				force = power / speed; //[N]

   208

				force *= 22;

   209

				force /= 10;

   210

			} break;

   211

			case 2:

   212

				force = power / 25;

   213

			break;

   214

		}

   215

	} else

   216

		//"kickoff" acceleration

   217

		force = resistance * 10;

   218

   219

	if (force <= 0) force = 10000;

   220

   221

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

   222

		force = min(force, mass * 10 * 200);

   223

   224

	if (mode == AM_ACCEL) {

   225

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

   226

	} else {

   227

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

   228

	}

   229

}

   230

   231

void UpdateTrainAcceleration(Vehicle *v)

   232

{

   233

	uint acc, power=0, max_speed=5000, weight=0;

   234

	Vehicle *u = v;

   235

   236

	assert(v->subtype == TS_Front_Engine);

   237

   238

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

   239

	do {

   240

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

   241

   242

		// power is sum of the power for all engines

   243

		power += rvi->power;

   244

   245

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

   246

		if (rvi->max_speed && rvi->max_speed <= max_speed) max_speed = rvi->max_speed;

   247

   248

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

   249

		weight += rvi->weight;

   250

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

   251

   252

	} while ( (u=u->next) != NULL);

   253

   254

	// these are shown in the UI

   255

	v->u.rail.cached_weight = weight;

   256

	v->u.rail.cached_power = power;

   257

	v->max_speed = max_speed;

   258

   259

	assert(weight != 0);

   260

   261

	// compute acceleration

   262

	acc = power / weight * 4;

   263

   264

	if (acc >= 255) acc=255;

   265

	if (acc == 0) acc++;

   266

   267

	v->acceleration = (byte)acc;

   268

}

   269

   270

int GetTrainImage(Vehicle *v, byte direction)

   271

{

   272

	int img = v->spritenum;

   273

	int base;

   274

   275

	if (is_custom_sprite(img)) {

   276

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

   277

		if (base) return base;

   278

		img = _engine_original_sprites[v->engine_type];

   279

	}

   280

   281

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

   282

   283

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

   284

		base += _wagon_full_adder[img];

   285

	return base;

   286

}

   287

   288

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

   289

{

   290

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   291

   292

	int img = rvi->image_index;

   293

	uint32 image = 0;

   294

   295

	if (is_custom_sprite(img)) {

   296

		image = GetCustomVehicleIcon(engine, 6);

   297

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

   298

	}

   299

	if (!image) {

   300

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

   301

	}

   302

   303

	if (rvi->flags & RVI_MULTIHEAD) {

   304

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

   305

		x += 15;

   306

		image = 0;

   307

		if (is_custom_sprite(img)) {

   308

			image = GetCustomVehicleIcon(engine, 2);

   309

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

   310

		}

   311

		if (!image) {

   312

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

   313

		}

   314

	}

   315

	DrawSprite(image | image_ormod, x, y);

   316

}

   317

   318

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

   319

{

   320

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   321

	int cap;

   322

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

   323

   324

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

   325

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

   326

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

   327

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

   328

   329

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

   330

   331

	cap = rvi->capacity;

   332

	SetDParam(5, STR_8838_N_A);

   333

	if (cap != 0) {

   334

		SetDParam(6, cap << multihead);

   335

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

   336

	}

   337

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   338

}

   339

   340

   341

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

   342

{

   343

	int32 value;

   344

	Vehicle *v;

   345

	const RailVehicleInfo *rvi;

   346

	int dir;

   347

	const Engine *e;

   348

	int x,y;

   349

   350

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   351

   352

	rvi = RailVehInfo(engine);

   353

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

   354

   355

	if (!(flags & DC_QUERY_COST)) {

   356

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   357

   358

		v = AllocateVehicle();

   359

		if (v == NULL)

   360

			return CMD_ERROR;

   361

   362

		if (flags & DC_EXEC) {

   363

			byte img = rvi->image_index;

   364

			Vehicle *u, *w;

   365

   366

			v->spritenum = img;

   367

   368

			u = NULL;

   369

   370

			FOR_ALL_VEHICLES(w) {

   371

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

   372

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

   373

					u = GetLastVehicleInChain(w);

   374

					break;

   375

				}

   376

			}

   377

   378

			v->engine_type = engine;

   379

   380

			dir = _map5[tile] & 3;

   381

   382

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

   383

			v->tile = (TileIndex)tile;

   384

   385

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

   386

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

   387

   388

			v->x_pos = x;

   389

			v->y_pos = y;

   390

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

   391

			v->owner = _current_player;

   392

			v->z_height = 6;

   393

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

   394

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   395

   396

			v->subtype = TS_Free_Car;

   397

			if (u != NULL) {

   398

				u->next = v;

   399

				v->subtype = TS_Not_First;

   400

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

   401

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

   402

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

   403

			} else {

   404

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

   405

			}

   406

   407

			v->cargo_type = rvi->cargo_type;

   408

			v->cargo_cap = rvi->capacity;

   409

			v->value = value;

   410

//			v->day_counter = 0;

   411

   412

			e = &_engines[engine];

   413

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

   414

   415

			v->build_year = _cur_year;

   416

			v->type = VEH_Train;

   417

			v->cur_image = 0xAC2;

   418

   419

			_new_wagon_id = v->index;

   420

   421

			VehiclePositionChanged(v);

   422

   423

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   424

		}

   425

	}

   426

   427

	return value;

   428

}

   429

   430

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

   431

static void NormalizeTrainVehInDepot(Vehicle *u)

   432

{

   433

	Vehicle *v;

   434

	FOR_ALL_VEHICLES(v) {

   435

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

   436

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

   437

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

   438

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

   439

				break;

   440

		}

   441

	}

   442

}

   443

   444

static const byte _railveh_unk1[] = {

   445

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

   446

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

   447

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

   448

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

   449

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

   450

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

   451

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

   452

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

   453

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

   454

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

   455

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

   459

	0, 0, 0, 0,

   460

};

   461

   462

static const byte _railveh_score[] = {

   463

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

   464

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

   465

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

   466

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

   470

	63, 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, 70, 71, 72, 73,

   474

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

   481

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   482

{

   483

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

   484

}

   485

   486

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

   487

{

   488

	u->direction = v->direction;

   489

	u->owner = v->owner;

   490

	u->tile = v->tile;

   491

	u->x_pos = v->x_pos;

   492

	u->y_pos = v->y_pos;

   493

	u->z_pos = v->z_pos;

   494

	u->z_height = 6;

   495

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

   496

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

   497

	u->vehstatus = v->vehstatus & ~VS_STOPPED;

   498

	u->subtype = TS_Not_First;

   499

	u->spritenum = v->spritenum + 1;

   500

	u->cargo_type = v->cargo_type;

   501

	u->cargo_cap = v->cargo_cap;

   502

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

   503

	if (building) v->next = u;

   504

	u->engine_type = v->engine_type;

   505

	u->build_year = v->build_year;

   506

	if (building)

   507

		v->value = u->value = v->value >> 1;