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

void UpdateTrainAcceleration(Vehicle *v)

    38

{

    39

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

    40

	Vehicle *u = v;

    41

    42

	assert(v->subtype == 0);

    43

    44

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

    45

	do {

    46

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

    47

    48

		// power is sum of the power for all engines

    49

		power += rvi->power;

    50

    51

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

    52

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

    53

    54

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

    55

		weight += rvi->weight;

    56

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

    57

    58

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

    59

    60

	// these are shown in the UI

    61

	v->u.rail.cached_weight = weight;

    62

	v->u.rail.cached_power = power;

    63

	v->max_speed = max_speed;

    64

    65

	assert(weight != 0);

    66

    67

	// compute acceleration

    68

	acc = power / weight * 4;

    69

    70

	if (acc >= 255) acc=255;

    71

	if (acc == 0) acc++;

    72

    73

	v->acceleration = (byte)acc;

    74

}

    75

    76

#define F_GRAV 9.82f

    77

#define F_THETA 0.05f

    78

    79

#define F_HP_KW 0.74569f

    80

#define F_KPH_MS 0.27778f

    81

#define F_MU 0.3f

    82

    83

#define F_COEF_FRIC 0.04f

    84

#define F_COEF_ROLL 0.18f

    85

    86

#define F_CURVE_FACTOR (1/96.f)

    87

    88

static bool IsTunnelTile(TileIndex tile);

    89

    90

static int GetRealisticAcceleration(Vehicle *v)

    91

{

    92

	uint emass = 0;

    93

	Vehicle *u = v;

    94

	float f = 0.0f, spd;

    95

	int curves = 0;

    96

    97

	assert(v->subtype == 0);

    98

    99

	// compute inclination force and number of curves.

   100

	do {

   101

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

   102

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

   103

		if (rvi->power) emass += mass;

   104

   105

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

   106

			f += (float)mass * ( -F_GRAV * F_THETA);

   107

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

   108

			f += (float)mass * ( F_GRAV * F_THETA);

   109

		}

   110

   111

		// compute curve penalty..

   112

		if (u->next != NULL) {

   113

			uint diff = (u->direction - u->next->direction) & 7;

   114

			if (diff) {

   115

				curves += (diff == 1 || diff == 7) ? 1 : 3;

   116

			}

   117

		}

   118

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

   119

   120

	spd = (float)(v->cur_speed ? v->cur_speed : 1);

   121

   122

	// compute tractive effort

   123

	{

   124

		float te = (float)v->u.rail.cached_power * (F_HP_KW/F_KPH_MS) / spd;

   125

		float te2 = (float)emass * (F_MU * F_GRAV);

   126

		if (te > te2) te = te2;

   127

		f += te;

   128

	}

   129

   130

	// add air resistance

   131

	{

   132

		float cx = 1.0f; // NOT DONE

   133

   134

		// air resistance is doubled in tunnels.

   135

		if (v->vehstatus == 0x40) cx *= 2;

   136

   137

		f -= cx * spd * spd * (F_KPH_MS * F_KPH_MS * 0.001f);

   138

	}

   139

   140

	// after this f contains the acceleration.

   141

	f /= (float)v->u.rail.cached_weight;

   142

   143

	// add friction to sum of forces (avoid mul by weight). (0.001 because we want kN)

   144

	f -= (F_COEF_FRIC * F_GRAV * 0.001f + (F_COEF_ROLL * F_KPH_MS * F_GRAV * 0.001f) * spd);

   145

   146

	// penalty for curves?

   147

	if (curves)

   148

		 f -= (float)min(curves, 8) * F_CURVE_FACTOR;

   149

   150

	return (int)(f  * (1.0/(F_KPH_MS * 0.015f)) + 0.5f);

   151

}

   152

   153

   154

int GetTrainImage(Vehicle *v, byte direction)

   155

{

   156

	int img = v->spritenum;

   157

	int base;

   158

   159

	if (is_custom_sprite(img)) {

   160

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

   161

		if (base) return base;

   162

		img = _engine_original_sprites[v->engine_type];

   163

	}

   164

   165

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

   166

   167

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

   168

		base += _wagon_full_adder[img];

   169

	return base;

   170

}

   171

   172

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

   173

{

   174

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   175

   176

	int img = rvi->image_index;

   177

	uint32 image = 0;

   178

   179

	if (is_custom_sprite(img)) {

   180

		image = GetCustomVehicleIcon(engine, 6);

   181

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

   182

	}

   183

	if (!image) {

   184

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

   185

	}

   186

   187

	if (rvi->flags & RVI_MULTIHEAD) {

   188

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

   189

		x += 15;

   190

		image = 0;

   191

		if (is_custom_sprite(img)) {

   192

			image = GetCustomVehicleIcon(engine, 2);

   193

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

   194

		}

   195

		if (!image) {

   196

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

   197

		}

   198

	}

   199

	DrawSprite(image | image_ormod, x, y);

   200

}

   201

   202

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

   203

{

   204

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   205

	int cap;

   206

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

   207

   208

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

   209

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

   210

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

   211

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

   212

   213

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

   214

   215

	cap = rvi->capacity;

   216

	SetDParam(5, STR_8838_N_A);

   217

	if (cap != 0) {

   218

		SetDParam(6, cap << multihead);

   219

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

   220

	}

   221

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   222

}

   223

   224

   225

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

   226

{

   227

	int32 value;

   228

	Vehicle *v;

   229

	const RailVehicleInfo *rvi;

   230

	int dir;

   231

	const Engine *e;

   232

	int x,y;

   233

   234

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   235

   236

	rvi = RailVehInfo(engine);

   237

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

   238

   239

	if (!(flags & DC_QUERY_COST)) {

   240

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   241

   242

		v = AllocateVehicle();

   243

		if (v == NULL)

   244

			return CMD_ERROR;

   245

   246

		if (flags & DC_EXEC) {

   247

			byte img = rvi->image_index;

   248

			Vehicle *u, *w;

   249

   250

			v->spritenum = img;

   251

   252

			u = NULL;

   253

   254

			FOR_ALL_VEHICLES(w) {

   255

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

   256

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

   257

					u = GetLastVehicleInChain(w);

   258

					break;

   259

				}

   260

			}

   261

   262

			v->engine_type = engine;

   263

   264

			dir = _map5[tile] & 3;

   265

   266

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

   267

			v->tile = (TileIndex)tile;

   268

   269

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

   270

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

   271

   272

			v->x_pos = x;

   273

			v->y_pos = y;

   274

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

   275

			v->owner = _current_player;

   276

			v->z_height = 6;

   277

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

   278

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   279

   280

			v->subtype = 4;

   281

			if (u != NULL) {

   282

				u->next = v;

   283

				v->subtype = 2;

   284

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

   285

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

   286

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

   287

			} else {

   288

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

   289

			}

   290

   291

			v->cargo_type = rvi->cargo_type;

   292

			v->cargo_cap = rvi->capacity;

   293

			v->value = value;

   294

//			v->day_counter = 0;

   295

   296

			e = &_engines[engine];

   297

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

   298

   299

			v->build_year = _cur_year;

   300

			v->type = VEH_Train;

   301

			v->cur_image = 0xAC2;

   302

   303

			_new_wagon_id = v->index;

   304

   305

			VehiclePositionChanged(v);

   306

   307

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   308

		}

   309

	}

   310

   311

	return value;

   312

}

   313

   314

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

   315

static void NormalizeTrainVehInDepot(Vehicle *u)

   316

{

   317

	Vehicle *v;

   318

	FOR_ALL_VEHICLES(v) {

   319

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

   320

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

   321

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

   322

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

   323

				break;

   324

		}

   325

	}

   326

}

   327

   328

static const byte _railveh_unk1[] = {

   329

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

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   336

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

   337

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

   338

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

   339

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

   340

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

   341

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

   342

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

   343

	0, 0, 0, 0,

   344

};

   345

   346

static const byte _railveh_score[] = {

   347

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

   348

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

   349

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

   350

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

   351

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

   352

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

   353

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

   354

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

   355

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

   356

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

   357

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

   358

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

   359

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

   360

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

   361

	0, 0, 0, 0,

   362

};

   363

   364

   365

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   366

{

   367

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

   368

}

   369

   370

/* Build a railroad vehicle

   371

 * p1 = vehicle type id

   372

 */

   373

   374

int32 CmdBuildRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   375

{

   376

	const RailVehicleInfo *rvi;

   377

	int value,dir;

   378

	Vehicle *v, *u;

   379

	byte unit_num;

   380

	Engine *e;

   381

	uint tile;

   382

   383

	_cmd_build_rail_veh_var1 = 0;

   384

   385

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   386

   387

	tile = TILE_FROM_XY(x,y);

   388

	rvi = RailVehInfo(p1);

   389

   390

	if (rvi->flags & RVI_WAGON) {

   391

		return CmdBuildRailWagon(p1, tile, flags);

   392

	}

   393

   394

	value = EstimateTrainCost(rvi);

   395

   396

	if (!(flags & DC_QUERY_COST)) {

   397

		v = AllocateVehicle();

   398

		if (v == NULL || IsOrderPoolFull())

   399

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   400

   401

		unit_num = GetFreeUnitNumber(VEH_Train);

   402

		if (unit_num > _patches.max_trains)

   403

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   404

   405

		if (flags & DC_EXEC) {

   406

			v->unitnumber = unit_num;

   407

   408

			dir = _map5[tile] & 3;

   409

   410

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

   411

			v->tile = (TileIndex)tile;

   412

			v->owner = _current_player;

   413

			v->x_pos = (x |= _vehicle_initial_x_fract[dir]);

   414

			v->y_pos = (y |= _vehicle_initial_y_fract[dir]);

   415

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

   416

			v->z_height = 6;

   417

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

   418

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

   419

			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   420

			v->spritenum = rvi->image_index;

   421

			v->cargo_type = rvi->cargo_type;

   422

			v->cargo_cap = rvi->capacity;

   423

			v->max_speed = rvi->max_speed;

   424

			v->value = value;

   425

			v->last_station_visited = 0xFFFF;

   426

			v->dest_tile = 0;

   427

   428

			v->engine_type = (byte)p1;

   429

			e = &_engines[p1];

   430

   431

			v->reliability = e->reliability;

   432

			v->reliability_spd_dec = e->reliability_spd_dec;

   433

			v->max_age = e->lifelength * 366;

   434

   435

			v->string_id = STR_SV_TRAIN_NAME;

   436

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

   437

			_new_train_id = v->index;

   438

   439

			v->service_interval = _patches.servint_trains;

   440

			v->date_of_last_service = _date;

   441

			v->build_year = _cur_year;

   442

			v->type = VEH_Train;

   443

			v->cur_image = 0xAC2;

   444

   445

			VehiclePositionChanged(v);

   446

   447

			if (rvi->flags&RVI_MULTIHEAD && (u=AllocateVehicle()) != NULL) {

   448

				u->direction = v->direction;

   449

				u->owner = v->owner;

   450

				u->tile = v->tile;

   451

				u->x_pos = v->x_pos;

   452

				u->y_pos = v->y_pos;

   453

				u->z_pos = v->z_pos;

   454

				u->z_height = 6;

   455

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

   456

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

   457

				u->vehstatus = VS_HIDDEN | VS_DEFPAL;

   458

				u->subtype = 2;

   459

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

   460

				u->cargo_type = v->cargo_type;

   461

				u->cargo_cap = v->cargo_cap;

   462

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

   463

//				u->next_in_chain = 0xffff;

   464

				v->next = u;

   465

				u->engine_type = v->engine_type;

   466

				u->build_year = v->build_year;

   467

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

   468

//				u->day_counter = 0;

   469

				u->type = VEH_Train;

   470

				u->cur_image = 0xAC2;

   471

				VehiclePositionChanged(u);

   472

			}

   473

   474

			UpdateTrainAcceleration(v);

   475

			NormalizeTrainVehInDepot(v);

   476

   477

			InvalidateWindow(WC_VEHICLE_DEPOT, tile);

   478

			RebuildVehicleLists();

   479

			InvalidateWindow(WC_COMPANY, v->owner);

   480

		}

   481

	}

   482

	_cmd_build_rail_veh_var1 = _railveh_unk1[p1];

   483

	_cmd_build_rail_veh_score = _railveh_score[p1];

   484

	return value;

   485

}

   486

   487

   488

bool IsTrainDepotTile(TileIndex tile)

   489

{

   490

	return IsTileType(tile, MP_RAILWAY) &&

   491

					(_map5[tile] & 0xFC) == 0xC0;

   492

}

   493

   494

static bool IsTunnelTile(TileIndex tile)

   495

{

   496

	return IsTileType(tile, MP_TUNNELBRIDGE) &&

   497

				 (_map5[tile]&0x80) == 0;

   498

}

   499

   500

   501

int CheckStoppedInDepot(Vehicle *v)

   502

{

   503

	int count;

   504

	TileIndex tile = v->tile;

   505

   506

	/* check if stopped in a depot */

   507

	if (!IsTrainDepotTile(tile) || v->cur_speed != 0) {

   508

errmsg:

   509

		_error_message = STR_881A_TRAINS_CAN_ONLY_BE_ALTERED;

   510

		return -1;

   511

	}

   512

   513

	count = 0;

   514

	do {

   515

		count++;

   516

		if (v->u.rail.track != 0x80 || v->tile != (TileIndex)tile ||

   517

				(v->subtype==0 && !(v->vehstatus&VS_STOPPED)))

   518

			goto errmsg;

   519

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