1

#include "stdafx.h"

     2

#include "ttd.h"

     4

#include "vehicle.h"

     5

#include "gfx.h"

     6

//#include "station.h"

     7

#include "viewport.h"

     8

#include "news.h"

     9

#include "command.h"

    10

#include "saveload.h"

    11

#include "player.h"

    12

#include "engine.h"

    13

#include "sound.h"

    14

    15

#define INVALID_COORD (-0x8000)

    16

#define GEN_HASH(x,y) (((x & 0x1F80)>>7) + ((y & 0xFC0)))

    17

    18

    19

void VehicleInTheWayErrMsg(Vehicle *v)

    20

{

    21

	StringID id;

    22

    23

	(id = STR_8803_TRAIN_IN_THE_WAY,v->type == VEH_Train) ||

    24

	(id = STR_9000_ROAD_VEHICLE_IN_THE_WAY,v->type == VEH_Road) ||

    25

	(id = STR_A015_AIRCRAFT_IN_THE_WAY,v->type == VEH_Aircraft) ||

    26

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    27

    28

	_error_message = id;

    29

}

    30

    31

static void *EnsureNoVehicleProc(Vehicle *v, void *data)

    32

{

    33

	if (v->tile != (TileIndex)(int)data || v->type == VEH_Disaster)

    34

		return NULL;

    35

    36

	VehicleInTheWayErrMsg(v);

    37

	return (void*)1;

    38

}

    39

    40

bool EnsureNoVehicle(TileIndex tile)

    41

{

    42

	return VehicleFromPos(tile, (void*)(int)tile, (VehicleFromPosProc*)EnsureNoVehicleProc) == NULL;

    43

}

    44

    45

static void *EnsureNoVehicleProcZ(Vehicle *v, void *data)

    46

{

    47

	uint32 d = (uint32)data;	// max mapsize 4,096*4,096 if shifted 8 bits for byte

    48

	// with uint64 max mapsize is 2,6843,5456*2,6843,5456 :D

    49

	if (v->tile != (TileIndex)(d >> (sizeof(byte)*8)) || v->z_pos != (byte)d || v->type == VEH_Disaster)

    50

		return NULL;

    51

    52

	VehicleInTheWayErrMsg(v);

    53

	return (void*)1;

    54

}

    55

    56

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    57

{

    58

	TileInfo ti;

    59

	FindLandscapeHeightByTile(&ti, tile);

    60

	// needs z correction for slope-type graphics that have the NORTHERN tile lowered

    61

	// 1, 2, 3, 4, 5, 6 and 7

    62

	if (CORRECT_Z(ti.tileh))

    63

		z += 8;

    64

    65

	return VehicleFromPos(tile, (void*)((TileIndex)tile << (sizeof(byte)*8) | (byte)z), (VehicleFromPosProc*)EnsureNoVehicleProcZ) == NULL;

    66

}

    67

    68

Vehicle *FindVehicleBetween(TileIndex from, TileIndex to, byte z)

    69

{

    70

	int x1 = GET_TILE_X(from);

    71

	int y1 = GET_TILE_Y(from);

    72

	int x2 = GET_TILE_X(to);

    73

	int y2 = GET_TILE_Y(to);

    74

	Vehicle *veh;

    75

	uint count;

    76

    77

	/* Make sure x1 < x2 or y1 < y2 */

    78

	if (x1 > x2 || y1 > y2) {

    79

		intswap(x1,x2);

    80

		intswap(y1,y2);

    81

	}

    82

	for(veh = _vehicles, count=lengthof(_vehicles); count != 0; count--, veh++) {

    83

		if ((veh->type == VEH_Train || veh->type == VEH_Road) && (z==0xFF || veh->z_pos == z)) {

    84

			if ((veh->x_pos>>4) >= x1 && (veh->x_pos>>4) <= x2 &&

    85

					(veh->y_pos>>4) >= y1 && (veh->y_pos>>4) <= y2) {

    86

				return veh;

    87

			}

    88

		}

    89

	}

    90

	return NULL;

    91

}

    92

    93

void VehiclePositionChanged(Vehicle *v)

    94

{

    95

	int img = v->cur_image;

    96

	const SpriteDimension *sd;

    97

	Point pt = RemapCoords(v->x_pos + v->x_offs, v->y_pos + v->y_offs, v->z_pos);

    98

    99

	sd = GetSpriteDimension(img);

   100

   101

	pt.x += sd->xoffs;

   102

	pt.y += sd->yoffs;

   103

   104

	UpdateVehiclePosHash(v, pt.x, pt.y);

   105

   106

	v->left_coord = pt.x;

   107

	v->top_coord = pt.y;

   108

	v->right_coord = pt.x + sd->xsize + 2;

   109

	v->bottom_coord = pt.y + sd->ysize + 2;

   110

}

   111

   112

void UpdateWaypointSign(Waypoint *cp)

   113

{

   114

	Point pt = RemapCoords2(GET_TILE_X(cp->xy)*16, GET_TILE_Y(cp->xy)*16);

   115

	SET_DPARAM16(0, cp - _waypoints);

   116

	UpdateViewportSignPos(&cp->sign, pt.x, pt.y - 0x20, STR_WAYPOINT_VIEWPORT);

   117

}

   118

   119

void RedrawWaypointSign(Waypoint *cp)

   120

{

   121

	MarkAllViewportsDirty(

   122

		cp->sign.left - 6,

   123

		cp->sign.top,

   124

		cp->sign.left + (cp->sign.width_1 << 2) + 12,

   125

		cp->sign.top + 48);

   126

}

   127

   128

// Called after load to update coordinates

   129

void AfterLoadVehicles()

   130

{

   131

	Vehicle *v;

   132

	Waypoint *cp;

   133

   134

	FOR_ALL_VEHICLES(v) {

   135

		if (v->type != 0) {

   136

			v->left_coord = INVALID_COORD;

   137

			VehiclePositionChanged(v);

   138

   139

			if (v->type == VEH_Train) {

   140

				if (v->subtype == 0)

   141

					UpdateTrainAcceleration(v);

   142

			}

   143

   144

#if defined(_DEBUG)

   145

			if (!(v->schedule_ptr == NULL || (v->schedule_ptr >= _order_array && v->schedule_ptr < _ptr_to_next_order)))

   146

				v->schedule_ptr = NULL;

   147

#endif

   148

		}

   149

	}

   150

   151

	// update waypoint signs

   152

	for(cp=_waypoints; cp != endof(_waypoints); cp++) if (cp->xy) UpdateWaypointSign(cp);

   153

}

   154

   155

   156

static Vehicle *InitializeVehicle(Vehicle *v)

   157

{

   158

	VehicleID index = v->index;

   159

	memset(v, 0, sizeof(Vehicle));

   160

	v->index = index;

   161

   162

	assert(v->schedule_ptr == NULL);

   163

   164

	v->left_coord = INVALID_COORD;

   165

	v->next = NULL;

   166

	v->next_hash = 0xffff;

   167

	v->string_id = 0;

   168

	v->random_bits = RandomRange(256);

   169

	return v;

   170

}

   171

   172

Vehicle *ForceAllocateSpecialVehicle()

   173

{

   174

	Vehicle *v;

   175

	for(v=_vehicles + NUM_NORMAL_VEHICLES;

   176

			v!=&_vehicles[NUM_NORMAL_VEHICLES+NUM_SPECIAL_VEHICLES]; v++) {

   177

		if (v->type == 0)

   178

			return InitializeVehicle(v);

   179

	}

   180

	return NULL;

   181

   182

}

   183

   184

Vehicle *ForceAllocateVehicle()

   185

{

   186

	Vehicle *v;

   187

	for(v=_vehicles; v!=&_vehicles[NUM_NORMAL_VEHICLES]; v++) {

   188

		if (v->type == 0)

   189

			return InitializeVehicle(v);

   190

	}

   191

	return NULL;

   192

}

   193

   194

Vehicle *AllocateVehicle()

   195

{

   196

	Vehicle *v;

   197

	int num;

   198

   199

	if (IS_HUMAN_PLAYER(_current_player)) {

   200

		num = 0;

   201

   202

		for(v=_vehicles; v!=&_vehicles[NUM_NORMAL_VEHICLES]; v++) {

   203

			if (v->type == 0)

   204

				num++;

   205

		}

   206

   207

		if (num <= 90)

   208

			return NULL;

   209

	}

   210

   211

	return ForceAllocateVehicle();

   212

}

   213

   214

void *VehicleFromPos(TileIndex tile, void *data, VehicleFromPosProc *proc)

   215

{

   216

	int x,y,x2,y2;

   217

	VehicleID veh;

   218

	Point pt = RemapCoords(GET_TILE_X(tile) * 16, GET_TILE_Y(tile) * 16, 0);

   219

   220

	x2 = ((pt.x + 104) & 0x1F80) >> 7;

   221

	x  = ((pt.x - 174) & 0x1F80) >> 7;

   222

   223

	y2 = ((pt.y + 56) & 0xFC0);

   224

	y  = ((pt.y - 294) & 0xFC0);

   225

   226

	for(;;) {

   227

		int xb = x;

   228

		for(;;) {

   229

			veh = _vehicle_position_hash[ (x+y)&0xFFFF ];

   230

			while (veh != INVALID_VEHICLE) {

   231

				Vehicle *v = &_vehicles[veh];

   232

				void *a;

   233

   234

				if ((a = proc(v, data)) != NULL)

   235

					return a;

   236

				veh = v->next_hash;

   237

			}

   238

   239

			if (x == x2)

   240

				break;

   241

   242

			x = (x + 1) & 0x3F;

   243

		}

   244

		x = xb;

   245

   246

		if (y == y2)

   247

			break;

   248

   249

		y = (y + 0x40) & ((0x3F) << 6);

   250

	}

   251

	return NULL;

   252

}

   253

   254

   255

   256

void UpdateVehiclePosHash(Vehicle *v, int x, int y)

   257

{

   258

	VehicleID *old_hash, *new_hash;

   259

	int old_x = v->left_coord;

   260

	int old_y = v->top_coord;

   261

	Vehicle *u;

   262

   263

	new_hash = (x == INVALID_COORD) ? NULL : &_vehicle_position_hash[GEN_HASH(x,y)];

   264

	old_hash = (old_x == INVALID_COORD) ? NULL : &_vehicle_position_hash[GEN_HASH(old_x, old_y)];

   265

   266

	if (old_hash == new_hash)

   267

		return;

   268

   269

	/* remove from hash table? */

   270

	if (old_hash != NULL) {

   271

		Vehicle *last = NULL;

   272

		int idx = *old_hash;

   273

		while((u = &_vehicles[idx]) != v) {

   274

			idx = u->next_hash;

   275

			assert(idx != INVALID_VEHICLE);

   276

			last = u;

   277

		}

   278

   279

		if (last == NULL)

   280

			*old_hash = v->next_hash;

   281

		else

   282

			last->next_hash = v->next_hash;

   283

	}

   284

   285

	/* insert into hash table? */

   286

	if (new_hash != NULL) {

   287

		v->next_hash = *new_hash;

   288

		*new_hash = v->index;

   289

	}

   290

}

   291

   292

void InitializeVehicles()

   293

{

   294

	Vehicle *v;

   295

	int i;

   296

   297

	// clear it...

   298

	memset(&_vehicles, 0, sizeof(_vehicles));

   299

	memset(&_waypoints, 0, sizeof(_waypoints));

   300

	memset(&_depots, 0, sizeof(_depots));

   301

   302

	// setup indexes..

   303

	i = 0;

   304

	FOR_ALL_VEHICLES(v)

   305

		v->index = i++;

   306

   307

	memset(_vehicle_position_hash, -1, sizeof(_vehicle_position_hash));

   308

   309

	_ptr_to_next_order = _order_array;

   310

}

   311

   312

Vehicle *GetLastVehicleInChain(Vehicle *v)

   313

{

   314

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

   315

	return v;

   316

}

   317

   318

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   319

{

   320

	Vehicle *org = v;

   321

   322

	v = _vehicles;

   323

	while (v->type != VEH_Train || org != v->next) {

   324

		if (++v == endof(_vehicles))

   325

			return NULL;

   326

	}

   327

   328

	return v;

   329

}

   330

   331

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   332

{

   333

	for(;;) {

   334

		Vehicle *u = v;

   335

		v = _vehicles;

   336

		while (v->type != VEH_Train || u != v->next) {

   337

			if (++v == endof(_vehicles))

   338

				return u;

   339

		}

   340

	}

   341

}

   342

   343

int CountVehiclesInChain(Vehicle *v)

   344

{

   345

	int count = 0;

   346

	do count++; while ( (v=v->next) != NULL);

   347

	return count;

   348

}

   349

   350

   351

Depot *AllocateDepot()

   352

{

   353

	Depot *dep, *free_dep = NULL;

   354

	int num_free = 0;

   355

   356

	for(dep = _depots; dep != endof(_depots); dep++) {

   357

		if (dep->xy == 0) {

   358

			num_free++;

   359

			if (free_dep==NULL)

   360

				free_dep = dep;

   361

		}

   362

	}

   363

   364

	if (free_dep == NULL ||

   365

			(num_free < 30 && IS_HUMAN_PLAYER(_current_player))) {

   366

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   367

		return NULL;

   368

	}

   369

   370

	return free_dep;

   371

}

   372

   373

Waypoint *AllocateWaypoint()

   374

{

   375

	Waypoint *cp;

   376

   377

	for(cp = _waypoints; cp != endof(_waypoints); cp++) {

   378

		if (cp->xy == 0)

   379

			return cp;

   380

	}

   381

   382

	return NULL;

   383

}

   384

   385

uint GetWaypointByTile(uint tile)

   386

{

   387

	Waypoint *cp;

   388

	int i=0;

   389

	for(cp=_waypoints; cp->xy != (TileIndex)tile; cp++) { i++; }

   390

	return i;

   391

}

   392

   393

   394

Vehicle *IsScheduleShared(Vehicle *u)

   395

{

   396

	uint16 *sched = u->schedule_ptr;

   397

	Vehicle *v;

   398

   399

	FOR_ALL_VEHICLES(v) {

   400

		if (v->schedule_ptr == sched && u != v && v->type != 0)

   401

			return v;

   402

	}

   403

	return NULL;

   404

}

   405

   406

void DeleteVehicleSchedule(Vehicle *v)

   407

{

   408

	uint16 *sched, *cur;

   409

	int num;

   410

	Vehicle *u;

   411

   412

	// if the schedule is shared, don't delete it.

   413

	if ((u = IsScheduleShared(v)) != NULL) {

   414

		v->schedule_ptr = NULL;

   415

		InvalidateWindow(WC_VEHICLE_ORDERS, u->index);

   416

		return;

   417

	}

   418

   419

	sched = v->schedule_ptr;

   420

	v->schedule_ptr = NULL;

   421

   422

	num = v->num_orders + 1;

   423

   424

	_ptr_to_next_order -= num;

   425

   426

	cur = sched;

   427

	while (cur != _ptr_to_next_order) {

   428

		assert(cur < _ptr_to_next_order);

   429

		cur[0] = cur[num];

   430

		cur++;

   431

	}

   432

   433

	FOR_ALL_VEHICLES(v) {

   434

		if (v->schedule_ptr != NULL && sched < v->schedule_ptr) {

   435

			v->schedule_ptr -= num;

   436

		}

   437

	}

   438

}

   439

   440

void DeleteCommandFromVehicleSchedule(uint cmd)

   441

{

   442

	Vehicle *v;

   443

	uint16 *sched;

   444

	uint order;

   445

	bool need_invalidate;

   446

   447

	FOR_ALL_VEHICLES(v) {

   448

		if (v->type != 0 && v->schedule_ptr != NULL) {

   449

   450

			// clear last station visited

   451

			if (v->last_station_visited == (cmd>>8) && (cmd & OT_MASK) == OT_GOTO_STATION)

   452

				v->last_station_visited = 0xFF;

   453

   454

			// check the next order

   455

			if ( (uint)((v->next_order&OT_MASK) | (v->next_order_param<<8)) == cmd) {

   456

				v->next_order = OT_DUMMY;

   457

				InvalidateWindow(WC_VEHICLE_VIEW, v->index);

   458

			}

   459

   460

			// clear the order list

   461

			need_invalidate = false;

   462

			sched = v->schedule_ptr;

   463

			while ((order=*sched++) != 0) {

   464

				if ( (order & (OT_MASK|0xFF00)) == cmd) {

   465

					sched[-1] = OT_DUMMY;

   466

					need_invalidate = true;

   467

				}

   468

			}

   469

   470

			if (need_invalidate)

   471

				InvalidateWindow(WC_VEHICLE_ORDERS, v->index);

   472

		}

   473

	}

   474

}

   475

   476

void DoDeleteDepot(uint tile)

   477

{

   478

	byte dep_index;

   479

	Depot *d;

   480

   481

	// Clear it

   482

	DoClearSquare(tile);

   483

   484

	// Nullify the depot struct

   485

	for(d=_depots,dep_index=0; d->xy != (TileIndex)tile; d++) {dep_index++;}

   486

	d->xy = 0;

   487

   488

	DeleteCommandFromVehicleSchedule((dep_index << 8) + OT_GOTO_DEPOT);

   489

   490

	// Delete the depot

   491

	DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   492

}

   493

   494

void DeleteVehicle(Vehicle *v)

   495

{

   496

	DeleteName(v->string_id);

   497

	v->type = 0;

   498

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   499

	v->next_hash = 0xffff;

   500

   501

	if (v->schedule_ptr != NULL)

   502

		DeleteVehicleSchedule(v);

   503

}

   504

   505

void DeleteVehicleChain(Vehicle *v)

   506

{

   507

	do {

   508

		Vehicle *u = v;

   509

		v = v->next;

   510

		DeleteVehicle(u);

   511

	} while (v);

   512

}

   513

   514

   515

void Aircraft_Tick(Vehicle *v);

   516

void RoadVeh_Tick(Vehicle *v);

   517

void Ship_Tick(Vehicle *v);

   518

void Train_Tick(Vehicle *v);

   519

static void EffectVehicle_Tick(Vehicle *v);

   520

void DisasterVehicle_Tick(Vehicle *v);

   521

   522

VehicleTickProc *_vehicle_tick_procs[] = {

   523

	Train_Tick,

   524

	RoadVeh_Tick,