1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "vehicle.h"

     5

#include "command.h"

     6

#include "pathfind.h"

     7

#include "station.h"

     8

#include "table/train_cmd.h"

     9

#include "gfx.h"

    10

#include "news.h"

    11

#include "engine.h"

    12

#include "player.h"

    13

#include "sound.h"

    14

    15

#define is_firsthead_sprite(spritenum) \

    16

	(is_custom_sprite(spritenum) \

    17

		? is_custom_firsthead_sprite(spritenum) \

    18

		: _engine_sprite_add[spritenum] == 0)

    19

    20

    21

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

    22

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

    23

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

    24

    25

static const byte _signal_onedir[14] = {

    26

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

    27

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

    28

};

    29

    30

static const byte _signal_otherdir[14] = {

    31

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

    32

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

    33

};

    34

    35

void UpdateTrainAcceleration(Vehicle *v)

    36

{

    37

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

    38

	Vehicle *u = v;

    39

    40

	assert(v->subtype == 0);

    41

    42

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

    43

	do {

    44

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

    45

    46

		// power is sum of the power for all engines

    47

		power += rvi->power;

    48

    49

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

    50

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

    51

    52

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

    53

		weight += rvi->weight;

    54

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

    55

    56

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

    57

    58

	// these are shown in the UI

    59

	v->u.rail.cached_weight = weight;

    60

	v->u.rail.cached_power = power;

    61

	v->max_speed = max_speed;

    62

    63

	assert(weight != 0);

    64

    65

	// compute acceleration

    66

	acc = power / weight * 4;

    67

    68

	if (acc >= 255) acc=255;

    69

	if (acc == 0) acc++;

    70

    71

	v->acceleration = (byte)acc;

    72

}

    73

    74

#define F_GRAV 9.82f

    75

#define F_THETA 0.05f

    76

    77

#define F_HP_KW 0.74569f

    78

#define F_KPH_MS 0.27778f

    79

#define F_MU 0.3f

    80

    81

#define F_COEF_FRIC 0.04f

    82

#define F_COEF_ROLL 0.18f

    83

    84

#define F_CURVE_FACTOR (1/96.f)

    85

    86

static bool IsTunnelTile(TileIndex tile);

    87

    88

static int GetRealisticAcceleration(Vehicle *v)

    89

{

    90

	uint emass = 0;

    91

	Vehicle *u = v;

    92

	float f = 0.0f, spd;

    93

	int curves = 0;

    94

    95

	assert(v->subtype == 0);

    96

    97

	// compute inclination force and number of curves.

    98

	do {

    99

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

   100

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

   101

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

   102

   103

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

   104

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

   105

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

   106

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

   107

		}

   108

   109

		// compute curve penalty..

   110

		if (u->next != NULL) {

   111

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

   112

			if (diff) {

   113

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

   114

			}

   115

		}

   116

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

   117

   118

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

   119

   120

	// compute tractive effort

   121

	{

   122

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

   123

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

   124

		if (te > te2) te = te2;

   125

		f += te;

   126

	}

   127

   128

	// add air resistance

   129

	{

   130

		float cx = 1.0f; // NOT DONE

   131

   132

		// air resistance is doubled in tunnels.

   133

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

   134

   135

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

   136

	}

   137

   138

	// after this f contains the acceleration.

   139

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

   140

   141

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

   142

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

   143

   144

	// penalty for curves?

   145

	if (curves)

   146

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

   147

   148

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

   149

}

   150

   151

   152

int GetTrainImage(Vehicle *v, byte direction)

   153

{

   154

	int img = v->spritenum;

   155

	int base;

   156

   157

	if (is_custom_sprite(img)) {

   158

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

   159

		if (base) return base;

   160

		img = _engine_original_sprites[v->engine_type];

   161

	}

   162

   163

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

   164

   165

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

   166

		base += _wagon_full_adder[img];

   167

	return base;

   168

}

   169

   170

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

   171

{

   172

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   173

   174

	int img = rvi->image_index;

   175

	uint32 image = 0;

   176

   177

	if (is_custom_sprite(img)) {

   178

		image = GetCustomVehicleIcon(engine, 6);

   179

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

   180

	}

   181

	if (!image) {

   182

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

   183

	}

   184

   185

	if (rvi->flags & RVI_MULTIHEAD) {

   186

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

   187

		x += 15;

   188

		image = 0;

   189

		if (is_custom_sprite(img)) {

   190

			image = GetCustomVehicleIcon(engine, 2);

   191

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

   192

		}

   193

		if (!image) {

   194

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

   195

		}

   196

	}

   197

	DrawSprite(image | image_ormod, x, y);

   198

}

   199

   200

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

   201

{

   202

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   203

	int cap;

   204

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

   205

   206

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

   207

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

   208

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

   209

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

   210

   211

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

   212

   213

	cap = rvi->capacity;

   214

	SetDParam(5, STR_8838_N_A);

   215

	if (cap != 0) {

   216

		SetDParam(6, cap << multihead);

   217

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

   218

	}

   219

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   220

}

   221

   222

   223

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

   224

{

   225

	int32 value;

   226

	Vehicle *v;

   227

	const RailVehicleInfo *rvi;

   228

	int dir;

   229

	const Engine *e;

   230

	int x,y;

   231

   232

	rvi = RailVehInfo(engine);

   233

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

   234

   235

	if (!(flags & DC_QUERY_COST)) {

   236

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   237

   238

		v = AllocateVehicle();

   239

		if (v == NULL)

   240

			return CMD_ERROR;

   241

   242

		if (flags & DC_EXEC) {

   243

			byte img = rvi->image_index;

   244

			Vehicle *u;

   245

   246

			v->spritenum = img;

   247

   248

			u = _vehicles;

   249

			for(;;) {

   250

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

   251

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

   252

					u = GetLastVehicleInChain(u);

   253

					break;

   254

				}

   255

   256

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

   257

					u = NULL;

   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 = GET_TILE_X(tile)*16 | _vehicle_initial_x_fract[dir];

   270

			y = GET_TILE_Y(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

static 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 || _ptr_to_next_order >= endof(_order_array))

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

   421

			v->spritenum = rvi->image_index;

   422

			v->cargo_type = rvi->cargo_type;

   423

			v->cargo_cap = rvi->capacity;

   424

			v->max_speed = rvi->max_speed;

   425

//			v->cargo_count = 0;

   426

			v->value = value;

   427

//			v->day_counter = 0;

   429

//			v->next_station = 0;

   430

//			v->load_unload_time_rem = 0;

   431

//			v->progress = 0;

   432

//			v->targetairport = 0;

   433

//			v->crash_anim_pos = 0;

   434

			v->last_station_visited = 0xff;

   435

			v->dest_tile = 0;

   436

//			v->profit_last_year = 0;

   437

//			v->profit_this_year = 0;

   438

   439

			v->engine_type = (byte)p1;

   440

			e = &_engines[p1];

   441

   442

			v->reliability = e->reliability;

   443

			v->reliability_spd_dec = e->reliability_spd_dec;

   444

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

   445

   446

			v->string_id = STR_SV_TRAIN_NAME;

   447

//			v->cur_speed = 0;

   448

//			v->subspeed = 0;

   449

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

   450

			_new_train_id = v->index;

   451

//			v->cur_order_index = 0;

   452

//			v->num_orders = 0;

   453

   457

//			v->next_in_chain = 0xffff;

   458

//			v->next = NULL;

   459

   460

			v->service_interval = _patches.servint_trains;

   461

//			v->breakdown_ctr = 0;

   462

//			v->breakdowns_since_last_service = 0;

   463

//			v->unk4D = 0;

   464

			v->date_of_last_service = _date;

   465

			v->build_year = _cur_year;

   466

			v->type = VEH_Train;

   467

			v->cur_image = 0xAC2;

   468

   469

			VehiclePositionChanged(v);

   470

   471

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

   472

				u->direction = v->direction;

   473

				u->owner = v->owner;

   474

				u->tile = v->tile;

   475

				u->x_pos = v->x_pos;

   476

				u->y_pos = v->y_pos;

   477

				u->z_pos = v->z_pos;

   478

				u->z_height = 6;

   479

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

   480

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

   481

				u->vehstatus = VS_HIDDEN | VS_DEFPAL;

   482

				u->subtype = 2;

   483

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

   484

				u->cargo_type = v->cargo_type;

   485

				u->cargo_cap = v->cargo_cap;

   486

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

   487

//				u->next_in_chain = 0xffff;

   488

				v->next = u;

   489

				u->engine_type = v->engine_type;

   490

				u->build_year = v->build_year;

   491

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

   492

//				u->day_counter = 0;

   493

				u->type = VEH_Train;

   494

				u->cur_image = 0xAC2;

   495

				VehiclePositionChanged(u);

   496

			}

   497

   498

			UpdateTrainAcceleration(v);

   499

			NormalizeTrainVehInDepot(v);

   500

   501

			InvalidateWindow(WC_VEHICLE_DEPOT, tile);

   502

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

   503

			InvalidateWindow(WC_TRAINS_LIST, v->owner);

   504

			InvalidateWindow(WC_COMPANY, v->owner);

   505

		}

   506

	}

   507

	_cmd_build_rail_veh_var1 = _railveh_unk1[p1];

   508

	_cmd_build_rail_veh_score = _railveh_score[p1];

   509

	return value;

   510

}

   511

   512

   513

bool IsTrainDepotTile(TileIndex tile)

   514

{

   515

	return IS_TILETYPE(tile, MP_RAILWAY) &&

   516

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

   517

}

   518

   519

static bool IsTunnelTile(TileIndex tile)

   520

{

   521

	return IS_TILETYPE(tile, MP_TUNNELBRIDGE) &&