1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "vehicle.h"

     4

#include "command.h"

     5

#include "pathfind.h"

     6

#include "station.h"

     7

#include "table/train_cmd.h"

     8

#include "gfx.h"

     9

#include "news.h"

    10

#include "engine.h"

    11

#include "player.h"

    12

#include "sound.h"

    13

    14

#define is_firsthead_sprite(spritenum) \

    15

	(is_custom_sprite(spritenum) \

    16

		? is_custom_firsthead_sprite(spritenum) \

    17

		: _engine_sprite_add[spritenum] == 0)

    18

    19

    20

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

    21

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

    22

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

    23

    24

static const byte _signal_onedir[14] = {

    25

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

    26

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

    27

};

    28

    29

static const byte _signal_otherdir[14] = {

    30

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

    31

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

    32

};

    33

    34

void UpdateTrainAcceleration(Vehicle *v)

    35

{

    36

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

    37

	Vehicle *u = v;

    38

    39

	assert(v->subtype == 0);

    40

    41

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

    42

	do {

    43

		const RailVehicleInfo *rvi = &_rail_vehicle_info[u->engine_type];

    44

    45

		// power is sum of the power for all engines

    46

		power += rvi->power;

    47

    48

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

    49

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

    50

    51

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

    52

		weight += rvi->weight;

    53

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

    54

    55

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

    56

    57

	// these are shown in the UI

    58

	v->u.rail.cached_weight = weight;

    59

	v->u.rail.cached_power = power;

    60

	v->max_speed = max_speed;

    61

    62

	assert(weight != 0);

    63

    64

	// compute acceleration

    65

	acc = power / weight * 4;

    66

    67

	if (acc >= 255) acc=255;

    68

	if (acc == 0) acc++;

    69

    70

	v->acceleration = (byte)acc;

    71

}

    72

    73

#define F_GRAV 9.82f

    74

#define F_THETA 0.05f

    75

    76

#define F_HP_KW 0.74569f

    77

#define F_KPH_MS 0.27778f

    78

#define F_MU 0.3f

    79

    80

#define F_COEF_FRIC 0.04f

    81

#define F_COEF_ROLL 0.18f

    82

    83

#define F_CURVE_FACTOR (1/96.f)

    84

    85

static bool IsTunnelTile(TileIndex tile);

    86

    87

static int GetRealisticAcceleration(Vehicle *v)

    88

{

    89

	uint emass = 0;

    90

	Vehicle *u = v;

    91

	float f = 0.0f, spd;

    92

	int curves = 0;

    93

    94

	assert(v->subtype == 0);

    95

    96

	// compute inclination force and number of curves.

    97

	do {

    98

		const RailVehicleInfo *rvi = &_rail_vehicle_info[u->engine_type];

    99

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

   100

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

   101

   102

		if (u->u.rail.flags & VRF_GOINGUP) {

   103

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

   104

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

   105

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

   106

		}

   107

   108

		// compute curve penalty..

   109

		if (u->next != NULL) {

   110

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

   111

			if (diff) {

   112

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

   113

			}

   114

		}

   115

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

   116

   117

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

   118

   119

	// compute tractive effort

   120

	{

   121

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

   122

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

   123

		if (te > te2) te = te2;

   124

		f += te;

   125

	}

   126

   127

	// add air resistance

   128

	{

   129

		float cx = 1.0f; // NOT DONE

   130

   131

		// air resistance is doubled in tunnels.

   132

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

   133

   134

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

   135

	}

   136

   137

	// after this f contains the acceleration.

   138

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

   139

   140

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

   141

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

   142

   143

	// penalty for curves?

   144

	if (curves)

   145

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

   146

   147

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

   148

}

   149

   150

   151

int GetTrainImage(Vehicle *v, byte direction)

   152

{

   153

	int img = v->spritenum;

   154

	int base;

   155

   156

	if (is_custom_sprite(img)) {

   157

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

   158

		if (base) return base;

   159

		img = _engine_original_sprites[v->engine_type];

   160

	}

   161

   162

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

   163

   164

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

   165

		base += _wagon_full_adder[img];

   166

	return base;

   167

}

   168

   169

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

   170

{

   171

	const RailVehicleInfo *rvi = &_rail_vehicle_info[engine];

   172

   173

	int img = rvi->image_index;

   174

	uint32 image = 0;

   175

   176

	if (is_custom_sprite(img)) {

   177

		image = GetCustomVehicleIcon(engine, 6);

   178

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

   179

	}

   180

	if (!image) {

   181

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

   182

	}

   183

   184

	if (rvi->flags & RVI_MULTIHEAD) {

   185

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

   186

		x += 15;

   187

		image = 0;

   188

		if (is_custom_sprite(img)) {

   189

			image = GetCustomVehicleIcon(engine, 2);

   190

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

   191

		}

   192

		if (!image) {

   193

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

   194

		}

   195

	}

   196

	DrawSprite(image | image_ormod, x, y);

   197

}

   198

   199

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

   200

{

   201

	const RailVehicleInfo *rvi = &_rail_vehicle_info[engine];

   202

	int cap;

   203

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

   204

   205

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

   206

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

   207

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

   208

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

   209

   210

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

   211

   212

	cap = rvi->capacity;

   213

	SET_DPARAM16(5, STR_8838_N_A);

   214

	if (cap != 0) {

   215

		SET_DPARAM16(6, cap << multihead);

   216

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

   217

	}

   218

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   219

}

   220

   221

   222

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

   223

{

   224

	int32 value;

   225

	Vehicle *v;

   226

	const RailVehicleInfo *rvi;

   227

	int dir;

   228

	const Engine *e;

   229

	int x,y;

   230

   231

	rvi = &_rail_vehicle_info[engine];

   232

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

   233

   234

	if (!(flags & DC_QUERY_COST)) {

   235

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   236

   237

		v = AllocateVehicle();

   238

		if (v == NULL)

   239

			return CMD_ERROR;

   240

   241

		if (flags & DC_EXEC) {

   242

			byte img = rvi->image_index;

   243

			Vehicle *u;

   244

   245

			v->spritenum = img;

   246

   247

			u = _vehicles;

   248

			for(;;) {

   249

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

   250

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

   251

					u = GetLastVehicleInChain(u);

   252

					break;

   253

				}

   254

   255

				if (++u == endof(_vehicles)) {

   256

					u = NULL;

   257

					break;

   258

				}

   259

			}

   260

   261

			v->engine_type = engine;

   262

   263

			dir = _map5[tile] & 3;

   264

   265

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

   266

			v->tile = (TileIndex)tile;

   267

   268

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

   269

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

   270

   271

			v->x_pos = x;

   272

			v->y_pos = y;

   273

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

   274

			v->owner = _current_player;

   275

			v->z_height = 6;

   276

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

   277

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   278

   279

			v->subtype = 4;

   280

			if (u != NULL) {

   281

				u->next = v;

   282

				v->subtype = 2;

   283

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

   284

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

   285

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

   286

			} else {

   287

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

   288

			}

   289

   290

			v->cargo_type = rvi->cargo_type;

   291

			v->cargo_cap = rvi->capacity;

   292

			v->value = value;

   293

//			v->day_counter = 0;

   294

   295

			e = &_engines[engine];

   296

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

   297

   298

			v->build_year = _cur_year;

   299

			v->type = VEH_Train;

   300

			v->cur_image = 0xAC2;

   301

   302

			_new_wagon_id = v->index;

   303

   304

			VehiclePositionChanged(v);

   305

   306

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   307

		}

   308

	}

   309

   310

	return value;

   311

}

   312

   313

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

   314

static void NormalizeTrainVehInDepot(Vehicle *u)

   315

{

   316

	Vehicle *v;

   317

	FOR_ALL_VEHICLES(v) {

   318

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

   319

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

   320

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

   321

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

   322

				break;

   323

		}

   324

	}

   325

}

   326

   327

static const byte _railveh_unk1[] = {

   328

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

   329

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

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   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,

   343

};

   344

   345

static const byte _railveh_score[] = {

   346

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

   347

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

   348

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

   349

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

   350

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

   351

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

   352

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

   353

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

   354

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

   355

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

   356

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

   357

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

   358

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

   359

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

   360

	0, 0, 0, 0,

   361

};

   362

   363

   364

static int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   365

{

   366

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

   367

}

   368

   369

/* Build a railroad vehicle

   370

 * p1 = vehicle type id

   371

 */

   372

   373

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

   374

{

   375

	const RailVehicleInfo *rvi;

   376

	int value,dir;

   377

	Vehicle *v, *u;

   378

	byte unit_num;

   379

	Engine *e;

   380

	uint tile;

   381

   382

	_cmd_build_rail_veh_var1 = 0;

   383

   384

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   385

   386

	tile = TILE_FROM_XY(x,y);

   387

	rvi = &_rail_vehicle_info[p1];

   388

   389

	if (rvi->flags & RVI_WAGON) {

   390

		return CmdBuildRailWagon(p1, tile, flags);

   391

	}

   392

   393

	value = EstimateTrainCost(rvi);

   394

   395

	if (!(flags & DC_QUERY_COST)) {

   396

		v = AllocateVehicle();

   397

		if (v == NULL || _ptr_to_next_order >= endof(_order_array))

   398

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   399

   400

		unit_num = GetFreeUnitNumber(VEH_Train);

   401

		if (unit_num > _patches.max_trains)

   402

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   403

   404

		if (flags & DC_EXEC) {

   405

			v->unitnumber = unit_num;

   406

   407

			dir = _map5[tile] & 3;

   408

   409

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

   410

			v->tile = (TileIndex)tile;

   411

			v->owner = _current_player;

   412

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

   413

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

   414

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

   415

			v->z_height = 6;

   416

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

   417

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

   418

			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   419

//			v->subtype = 0;

   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->cargo_count = 0;

   425

			v->value = value;

   426

//			v->day_counter = 0;

   427

//			v->next_order = 0;

   428

//			v->next_station = 0;

   429

//			v->load_unload_time_rem = 0;

   430

//			v->progress = 0;

   431

//			v->targetairport = 0;

   432

//			v->crash_anim_pos = 0;

   433

			v->last_station_visited = 0xff;

   434

			v->dest_tile = 0;

   435

//			v->profit_last_year = 0;

   436

//			v->profit_this_year = 0;

   437

   438

			v->engine_type = (byte)p1;

   439

			e = &_engines[p1];

   440

   441

			v->reliability = e->reliability;

   442

			v->reliability_spd_dec = e->reliability_spd_dec;

   443

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

   444

   445

			v->string_id = STR_SV_TRAIN_NAME;

   446

//			v->cur_speed = 0;

   447

//			v->subspeed = 0;

   448

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

   449

			_new_train_id = v->index;

   450

//			v->cur_order_index = 0;

   451

//			v->num_orders = 0;

   452

   453

			*(v->schedule_ptr = _ptr_to_next_order++) = 0;

   454

//			v->next_in_chain = 0xffff;

   455

//			v->next = NULL;

   456

   457

			v->service_interval = _patches.servint_trains;

   458

//			v->breakdown_ctr = 0;

   459

//			v->breakdowns_since_last_service = 0;

   460

//			v->unk4D = 0;

   461

			v->date_of_last_service = _date;

   462

			v->build_year = _cur_year;

   463

			v->type = VEH_Train;

   464

			v->cur_image = 0xAC2;

   465

   466

			VehiclePositionChanged(v);

   467

   468

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

   469

				u->direction = v->direction;

   470

				u->owner = v->owner;

   471

				u->tile = v->tile;

   472

				u->x_pos = v->x_pos;

   473

				u->y_pos = v->y_pos;

   474

				u->z_pos = v->z_pos;

   475

				u->z_height = 6;

   476

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

   477

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

   478

				u->vehstatus = VS_HIDDEN | VS_DEFPAL;

   479

				u->subtype = 2;

   480

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

   481

				u->cargo_type = v->cargo_type;

   482

				u->cargo_cap = v->cargo_cap;

   483

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

   484

//				u->next_in_chain = 0xffff;

   485

				v->next = u;

   486

				u->engine_type = v->engine_type;

   487

				u->build_year = v->build_year;

   488

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

   489

//				u->day_counter = 0;

   490

				u->type = VEH_Train;

   491

				u->cur_image = 0xAC2;

   492

				VehiclePositionChanged(u);

   493

			}

   494

   495

			UpdateTrainAcceleration(v);

   496

			NormalizeTrainVehInDepot(v);

   497

   498

			InvalidateWindow(WC_VEHICLE_DEPOT, tile);

   499

			_vehicle_sort_dirty[VEHTRAIN] = true; // build a trainengine

   500

			InvalidateWindow(WC_TRAINS_LIST, v->owner);

   501

			InvalidateWindow(WC_COMPANY, v->owner);

   502

		}

   503

	}

   504

	_cmd_build_rail_veh_var1 = _railveh_unk1[p1];

   505

	_cmd_build_rail_veh_score = _railveh_score[p1];

   506

	return value;

   507

}

   508

   509

   510

bool IsTrainDepotTile(TileIndex tile)

   511

{

   512

	return IS_TILETYPE(tile, MP_RAILWAY) &&

   513

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

   514

}

   515

   516

static bool IsTunnelTile(TileIndex tile)

   517

{

   518

	return IS_TILETYPE(tile, MP_TUNNELBRIDGE) &&

   519

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

   520

}

   521

   522

   523

int CheckStoppedInDepot(Vehicle *v)

   524

{