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

    22

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

    23

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

    24

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

    25

    26

static const byte _signal_onedir[14] = {

    27

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

    28

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

    29

};

    30

    31

static const byte _signal_otherdir[14] = {

    32

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

    33

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

    34

};

    35

    36

void UpdateTrainAcceleration(Vehicle *v)

    37

{

    38

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

    39

	Vehicle *u = v;

    40

    41

	assert(v->subtype == 0);

    42

    43

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

    44

	do {

    45

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

    46

    47

		// power is sum of the power for all engines

    48

		power += rvi->power;

    49

    50

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

    51

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

    52

    53

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

    54

		weight += rvi->weight;

    55

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

    56

    57

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

    58

    59

	// these are shown in the UI

    60

	v->u.rail.cached_weight = weight;

    61

	v->u.rail.cached_power = power;

    62

	v->max_speed = max_speed;

    63

    64

	assert(weight != 0);

    65

    66

	// compute acceleration

    67

	acc = power / weight * 4;

    68

    69

	if (acc >= 255) acc=255;

    70

	if (acc == 0) acc++;

    71

    72

	v->acceleration = (byte)acc;

    73

}

    74

    75

#define F_GRAV 9.82f

    76

#define F_THETA 0.05f

    77

    78

#define F_HP_KW 0.74569f

    79

#define F_KPH_MS 0.27778f

    80

#define F_MU 0.3f

    81

    82

#define F_COEF_FRIC 0.04f

    83

#define F_COEF_ROLL 0.18f

    84

    85

#define F_CURVE_FACTOR (1/96.f)

    86

    87

static bool IsTunnelTile(TileIndex tile);

    88

    89

static int GetRealisticAcceleration(Vehicle *v)

    90

{

    91

	uint emass = 0;

    92

	Vehicle *u = v;

    93

	float f = 0.0f, spd;

    94

	int curves = 0;

    95

    96

	assert(v->subtype == 0);

    97

    98

	// compute inclination force and number of curves.

    99

	do {

   100

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

   101

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

   102

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

   103

   104

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

   105

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

   106

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

   107

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

   108

		}

   109

   110

		// compute curve penalty..

   111

		if (u->next != NULL) {

   112

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

   113

			if (diff) {

   114

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

   115

			}

   116

		}

   117

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

   118

   119

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

   120

   121

	// compute tractive effort

   122

	{

   123

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

   124

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

   125

		if (te > te2) te = te2;

   126

		f += te;

   127

	}

   128

   129

	// add air resistance

   130

	{

   131

		float cx = 1.0f; // NOT DONE

   132

   133

		// air resistance is doubled in tunnels.

   134

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

   135

   136

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

   137

	}

   138

   139

	// after this f contains the acceleration.

   140

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

   141

   142

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

   143

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

   144

   145

	// penalty for curves?

   146

	if (curves)

   147

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

   148

   149

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

   150

}

   151

   152

   153

int GetTrainImage(Vehicle *v, byte direction)

   154

{

   155

	int img = v->spritenum;

   156

	int base;

   157

   158

	if (is_custom_sprite(img)) {

   159

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

   160

		if (base) return base;

   161

		img = _engine_original_sprites[v->engine_type];

   162

	}

   163

   164

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

   165

   166

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

   167

		base += _wagon_full_adder[img];

   168

	return base;

   169

}

   170

   171

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

   172

{

   173

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   174

   175

	int img = rvi->image_index;

   176

	uint32 image = 0;

   177

   178

	if (is_custom_sprite(img)) {

   179

		image = GetCustomVehicleIcon(engine, 6);

   180

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

   181

	}

   182

	if (!image) {

   183

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

   184

	}

   185

   186

	if (rvi->flags & RVI_MULTIHEAD) {

   187

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

   188

		x += 15;

   189

		image = 0;

   190

		if (is_custom_sprite(img)) {

   191

			image = GetCustomVehicleIcon(engine, 2);

   192

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

   193

		}

   194

		if (!image) {

   195

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

   196

		}

   197

	}

   198

	DrawSprite(image | image_ormod, x, y);

   199

}

   200

   201

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

   202

{

   203

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   204

	int cap;

   205

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

   206

   207

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

   208

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

   209

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

   210

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

   211

   212

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

   213

   214

	cap = rvi->capacity;

   215

	SetDParam(5, STR_8838_N_A);

   216

	if (cap != 0) {

   217

		SetDParam(6, cap << multihead);

   218

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

   219

	}

   220

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   221

}

   222

   223

   224

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

   225

{

   226

	int32 value;

   227

	Vehicle *v;

   228

	const RailVehicleInfo *rvi;

   229

	int dir;

   230

	const Engine *e;

   231

	int x,y;

   232

   233

	rvi = RailVehInfo(engine);

   234

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

   235

   236

	if (!(flags & DC_QUERY_COST)) {

   237

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   238

   239

		v = AllocateVehicle();

   240

		if (v == NULL)

   241

			return CMD_ERROR;

   242

   243

		if (flags & DC_EXEC) {

   244

			byte img = rvi->image_index;

   245

			Vehicle *u;

   246

   247

			v->spritenum = img;

   248

   249

			u = _vehicles;

   250

			for(;;) {

   251

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

   252

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

   253

					u = GetLastVehicleInChain(u);

   254

					break;

   255

				}

   256

   257

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

   258

					u = NULL;

   259

					break;

   260

				}

   261

			}

   262

   263

			v->engine_type = engine;

   264

   265

			dir = _map5[tile] & 3;

   266

   267

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

   268

			v->tile = (TileIndex)tile;

   269

   270

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

   271

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

   272

   273

			v->x_pos = x;

   274

			v->y_pos = y;

   275

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

   276

			v->owner = _current_player;

   277

			v->z_height = 6;

   278

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

   279

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   280

   281

			v->subtype = 4;

   282

			if (u != NULL) {

   283

				u->next = v;

   284

				v->subtype = 2;

   285

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

   286

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

   287

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

   288

			} else {

   289

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

   290

			}

   291

   292

			v->cargo_type = rvi->cargo_type;

   293

			v->cargo_cap = rvi->capacity;

   294

			v->value = value;

   295

//			v->day_counter = 0;

   296

   297

			e = &_engines[engine];

   298

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

   299

   300

			v->build_year = _cur_year;

   301

			v->type = VEH_Train;

   302

			v->cur_image = 0xAC2;

   303

   304

			_new_wagon_id = v->index;

   305

   306

			VehiclePositionChanged(v);

   307

   308

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   309

		}

   310

	}

   311

   312

	return value;

   313

}

   314

   315

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

   316

static void NormalizeTrainVehInDepot(Vehicle *u)

   317

{

   318

	Vehicle *v;

   319

	FOR_ALL_VEHICLES(v) {

   320

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

   321

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

   322

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

   323

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

   324

				break;

   325

		}

   326

	}

   327

}

   328

   329

static const byte _railveh_unk1[] = {

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   336

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

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

   344

	0, 0, 0, 0,

   345

};

   346

   347

static const byte _railveh_score[] = {

   348

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

   349

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

   350

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

   351

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

   352

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

   353

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

   354

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

   355

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

   356

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

   357

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

   358

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

   359

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

   360

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

   361

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

   362

	0, 0, 0, 0,

   363

};

   364

   365

   366

static int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   367

{

   368

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

   369

}

   370

   371

/* Build a railroad vehicle

   372

 * p1 = vehicle type id

   373

 */

   374

   375

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

   376

{

   377

	const RailVehicleInfo *rvi;

   378

	int value,dir;

   379

	Vehicle *v, *u;

   380

	byte unit_num;

   381

	Engine *e;

   382

	uint tile;

   383

   384

	_cmd_build_rail_veh_var1 = 0;

   385

   386

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   387

   388

	tile = TILE_FROM_XY(x,y);

   389

	rvi = RailVehInfo(p1);

   390

   391

	if (rvi->flags & RVI_WAGON) {

   392

		return CmdBuildRailWagon(p1, tile, flags);

   393

	}

   394

   395

	value = EstimateTrainCost(rvi);

   396

   397

	if (!(flags & DC_QUERY_COST)) {

   398

		v = AllocateVehicle();

   399

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

   400

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   401

   402

		unit_num = GetFreeUnitNumber(VEH_Train);

   403

		if (unit_num > _patches.max_trains)

   404

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   405

   406

		if (flags & DC_EXEC) {

   407

			v->unitnumber = unit_num;

   408

   409

			dir = _map5[tile] & 3;

   410

   411

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

   412

			v->tile = (TileIndex)tile;

   413

			v->owner = _current_player;

   414

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

   415

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

   416

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

   417

			v->z_height = 6;

   418

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

   419

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

   420

			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   421

//			v->subtype = 0;

   422

			v->spritenum = rvi->image_index;

   423

			v->cargo_type = rvi->cargo_type;

   424

			v->cargo_cap = rvi->capacity;

   425

			v->max_speed = rvi->max_speed;

   426

//			v->cargo_count = 0;

   427

			v->value = value;

   428

//			v->day_counter = 0;

   429

//			v->current_order = 0;

   430

//			v->next_station = 0;

   431

//			v->load_unload_time_rem = 0;

   432

//			v->progress = 0;

   433

//			v->targetairport = 0;

   434

//			v->crash_anim_pos = 0;

   435

			v->last_station_visited = 0xff;

   436

			v->dest_tile = 0;

   437

//			v->profit_last_year = 0;

   438

//			v->profit_this_year = 0;

   439

   440

			v->engine_type = (byte)p1;

   441

			e = &_engines[p1];

   442

   443

			v->reliability = e->reliability;

   444

			v->reliability_spd_dec = e->reliability_spd_dec;

   445

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

   446

   447

			v->string_id = STR_SV_TRAIN_NAME;

   448

//			v->cur_speed = 0;

   449

//			v->subspeed = 0;

   450

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

   451

			_new_train_id = v->index;

   452

//			v->cur_order_index = 0;

   453

//			v->num_orders = 0;

   454

   455

			_ptr_to_next_order->type = OT_NOTHING;

   456

			_ptr_to_next_order->flags = 0;

   457

			v->schedule_ptr = _ptr_to_next_order++;

   458

//			v->next_in_chain = 0xffff;

   459

//			v->next = NULL;

   460

   461

			v->service_interval = _patches.servint_trains;

   462

//			v->breakdown_ctr = 0;

   463

//			v->breakdowns_since_last_service = 0;

   464

//			v->unk4D = 0;

   465

			v->date_of_last_service = _date;

   466

			v->build_year = _cur_year;

   467

			v->type = VEH_Train;

   468

			v->cur_image = 0xAC2;

   469

   470

			VehiclePositionChanged(v);

   471

   472

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

   473

				u->direction = v->direction;

   474

				u->owner = v->owner;

   475

				u->tile = v->tile;

   476

				u->x_pos = v->x_pos;

   477

				u->y_pos = v->y_pos;

   478

				u->z_pos = v->z_pos;

   479

				u->z_height = 6;

   480

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

   481

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

   482

				u->vehstatus = VS_HIDDEN | VS_DEFPAL;

   483

				u->subtype = 2;

   484

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

   485

				u->cargo_type = v->cargo_type;

   486

				u->cargo_cap = v->cargo_cap;

   487

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

   488

//				u->next_in_chain = 0xffff;

   489

				v->next = u;

   490

				u->engine_type = v->engine_type;

   491

				u->build_year = v->build_year;

   492

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

   493

//				u->day_counter = 0;

   494

				u->type = VEH_Train;

   495

				u->cur_image = 0xAC2;

   496

				VehiclePositionChanged(u);

   497

			}

   498

   499

			UpdateTrainAcceleration(v);

   500

			NormalizeTrainVehInDepot(v);

   501

   502

			InvalidateWindow(WC_VEHICLE_DEPOT, tile);

   503

			RebuildVehicleLists();

   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) &&