1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "vehicle.h"

     4

#include "gfx.h"

     5

//#include "station.h"

     6

#include "viewport.h"

     7

#include "news.h"

     8

#include "command.h"

     9

#include "saveload.h"

    10

#include "player.h"

    11

#include "engine.h"

    12

#include "sound.h"

    13

    14

#define INVALID_COORD (-0x8000)

    15

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

    16

    17

    18

void VehicleInTheWayErrMsg(Vehicle *v)

    19

{

    20

	StringID id;

    21

    22

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

    23

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

    24

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

    25

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    26

    27

	_error_message = id;

    28

}

    29

    30

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

    31

{

    32

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

    33

		return NULL;

    34

    35

	VehicleInTheWayErrMsg(v);

    36

	return (void*)1;

    37

}

    38

    39

bool EnsureNoVehicle(TileIndex tile)

    40

{

    41

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

    42

}

    43

    44

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

    45

{

    46

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

    47

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

    48

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

    49

		return NULL;

    50

    51

	VehicleInTheWayErrMsg(v);

    52

	return (void*)1;

    53

}

    54

    55

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    56

{

    57

	TileInfo ti;

    58

	FindLandscapeHeightByTile(&ti, tile);

    59

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

    60

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

    61

	if (CORRECT_Z(ti.tileh))

    62

		z += 8;

    63

    64

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

    65

}

    66

    67

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

    68

{

    69

	int x1 = GET_TILE_X(from);

    70

	int y1 = GET_TILE_Y(from);

    71

	int x2 = GET_TILE_X(to);

    72

	int y2 = GET_TILE_Y(to);

    73

	Vehicle *veh;

    74

	uint count;

    75

    76

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

    77

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

    78

		intswap(x1,x2);

    79

		intswap(y1,y2);

    80

	}

    81

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

    82

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

    83

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

    84

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

    85

				return veh;

    86

			}

    87

		}

    88

	}

    89

	return NULL;

    90

}

    91

    92

void VehiclePositionChanged(Vehicle *v)

    93

{

    94

	int img = v->cur_image;

    95

	const SpriteDimension *sd;

    96

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

    97

    98

	sd = GetSpriteDimension(img);

    99

   100

	pt.x += sd->xoffs;

   101

	pt.y += sd->yoffs;

   102

   103

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

   104

   105

	v->left_coord = pt.x;

   106

	v->top_coord = pt.y;

   107

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

   108

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

   109

}

   110

   111

void UpdateWaypointSign(Waypoint *cp)

   112

{

   113

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

   114

	SET_DPARAM16(0, cp - _waypoints);

   115

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

   116

}

   117

   118

void RedrawWaypointSign(Waypoint *cp)

   119

{

   120

	MarkAllViewportsDirty(

   121

		cp->sign.left - 6,

   122

		cp->sign.top,

   123

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

   124

		cp->sign.top + 48);

   125

}

   126

   127

// Called after load to update coordinates

   128

void AfterLoadVehicles()

   129

{

   130

	Vehicle *v;

   131

	Waypoint *cp;

   132

   133

	FOR_ALL_VEHICLES(v) {

   134

		if (v->type != 0) {

   135

			v->left_coord = INVALID_COORD;

   136

			VehiclePositionChanged(v);

   137

   138

			if (v->type == VEH_Train) {

   139

				if (v->subtype == 0)

   140

					UpdateTrainAcceleration(v);

   141

			}

   142

   143

#if defined(_DEBUG)

   144

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

   145

				v->schedule_ptr = NULL;

   146

#endif

   147

		}

   148

	}

   149

   150

	// update waypoint signs

   151

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

   152

}

   153

   154

   155

static Vehicle *InitializeVehicle(Vehicle *v)

   156

{

   157

	VehicleID index = v->index;

   158

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

   159

	v->index = index;

   160

   161

	assert(v->schedule_ptr == NULL);

   162

   163

	v->left_coord = INVALID_COORD;

   164

	v->next = NULL;

   165

	v->next_hash = 0xffff;

   166

	v->string_id = 0;

   167

	return v;

   168

}

   169

   170

Vehicle *ForceAllocateSpecialVehicle()

   171

{

   172

	Vehicle *v;

   173

	for(v=_vehicles + NUM_NORMAL_VEHICLES;

   174

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

   175

		if (v->type == 0)

   176

			return InitializeVehicle(v);

   177

	}

   178

	return NULL;

   179

   180

}

   181

   182

Vehicle *ForceAllocateVehicle()

   183

{

   184

	Vehicle *v;

   185

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

   186

		if (v->type == 0)

   187

			return InitializeVehicle(v);

   188

	}

   189

	return NULL;

   190

}

   191

   192

Vehicle *AllocateVehicle()

   193

{

   194

	Vehicle *v;

   195

	int num;

   196

   197

	if (IS_HUMAN_PLAYER(_current_player)) {

   198

		num = 0;

   199

   200

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

   201

			if (v->type == 0)

   202

				num++;

   203

		}

   204

   205

		if (num <= 90)

   206

			return NULL;

   207

	}

   208

   209

	return ForceAllocateVehicle();

   210

}

   211

   212

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

   213

{

   214

	int x,y,x2,y2;

   215

	VehicleID veh;

   216

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

   217

   218

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

   219

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

   220

   221

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

   222

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

   223

   224

	for(;;) {

   225

		int xb = x;

   226

		for(;;) {

   227

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

   228

			while (veh != INVALID_VEHICLE) {

   229

				Vehicle *v = &_vehicles[veh];

   230

				void *a;

   231

   232

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

   233

					return a;

   234

				veh = v->next_hash;

   235

			}

   236

   237

			if (x == x2)

   238

				break;

   239

   240

			x = (x + 1) & 0x3F;

   241

		}

   242

		x = xb;

   243

   244

		if (y == y2)

   245

			break;

   246

   247

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

   248

	}

   249

	return NULL;

   250

}

   251

   252

   253

   254

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

   255

{

   256

	VehicleID *old_hash, *new_hash;

   257

	int old_x = v->left_coord;

   258

	int old_y = v->top_coord;

   259

	Vehicle *u;

   260

   261

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

   262

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

   263

   264

	if (old_hash == new_hash)

   265

		return;

   266

   267

	/* remove from hash table? */

   268

	if (old_hash != NULL) {

   269

		Vehicle *last = NULL;

   270

		int idx = *old_hash;

   271

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

   272

			idx = u->next_hash;

   273

			assert(idx != INVALID_VEHICLE);

   274

			last = u;

   275

		}

   276

   277

		if (last == NULL)

   278

			*old_hash = v->next_hash;

   279

		else

   280

			last->next_hash = v->next_hash;

   281

	}

   282

   283

	/* insert into hash table? */

   284

	if (new_hash != NULL) {

   285

		v->next_hash = *new_hash;

   286

		*new_hash = v->index;

   287

	}

   288

}

   289

   290

void InitializeVehicles()

   291

{

   292

	Vehicle *v;

   293

	int i;

   294

   295

	// clear it...

   296

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

   297

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

   298

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

   299

   300

	// setup indexes..

   301

	i = 0;

   302

	FOR_ALL_VEHICLES(v)

   303

		v->index = i++;

   304

   305

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

   306

   307

	_ptr_to_next_order = _order_array;

   308

}

   309

   310

Vehicle *GetLastVehicleInChain(Vehicle *v)

   311

{

   312

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

   313

	return v;

   314

}

   315

   316

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   317

{

   318

	Vehicle *org = v;

   319

   320

	v = _vehicles;

   321

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

   322

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

   323

			return NULL;

   324

	}

   325

   326

	return v;

   327

}

   328

   329

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   330

{

   331

	for(;;) {

   332

		Vehicle *u = v;

   333

		v = _vehicles;

   334

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

   335

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

   336

				return u;

   337

		}

   338

	}

   339

}

   340

   341

int CountVehiclesInChain(Vehicle *v)

   342

{

   343

	int count = 0;

   344

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

   345

	return count;

   346

}

   347

   348

   349

Depot *AllocateDepot()

   350

{

   351

	Depot *dep, *free_dep = NULL;

   352

	int num_free = 0;

   353

   354

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

   355

		if (dep->xy == 0) {

   356

			num_free++;

   357

			if (free_dep==NULL)

   358

				free_dep = dep;

   359

		}

   360

	}

   361

   362

	if (free_dep == NULL ||

   363

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

   364

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   365

		return NULL;

   366

	}

   367

   368

	return free_dep;

   369

}

   370

   371

Waypoint *AllocateWaypoint()

   372

{

   373

	Waypoint *cp;

   374

   375

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

   376

		if (cp->xy == 0)

   377

			return cp;

   378

	}

   379

   380

	return NULL;

   381

}

   382

   383

uint GetWaypointByTile(uint tile)

   384

{

   385

	Waypoint *cp;

   386

	int i=0;

   387

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

   388

	return i;

   389

}

   390

   391

   392

Vehicle *IsScheduleShared(Vehicle *u)

   393

{

   394

	uint16 *sched = u->schedule_ptr;

   395

	Vehicle *v;

   396

   397

	FOR_ALL_VEHICLES(v) {

   398

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

   399

			return v;

   400

	}

   401

	return NULL;

   402

}

   403

   404

void DeleteVehicleSchedule(Vehicle *v)

   405

{

   406

	uint16 *sched, *cur;

   407

	int num;

   408

	Vehicle *u;

   409

   410

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

   411

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

   412

		v->schedule_ptr = NULL;

   413

		InvalidateWindow(WC_VEHICLE_ORDERS, u->index);

   414

		return;

   415

	}

   416

   417

	sched = v->schedule_ptr;

   418

	v->schedule_ptr = NULL;

   419

   420

	num = v->num_orders + 1;

   421

   422

	_ptr_to_next_order -= num;

   423

   424

	cur = sched;

   425

	while (cur != _ptr_to_next_order) {

   426

		assert(cur < _ptr_to_next_order);

   427

		cur[0] = cur[num];

   428

		cur++;

   429

	}

   430

   431

	FOR_ALL_VEHICLES(v) {

   432

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

   433

			v->schedule_ptr -= num;

   434

		}

   435

	}

   436

}

   437

   438

void DeleteCommandFromVehicleSchedule(uint cmd)

   439

{

   440

	Vehicle *v;

   441

	uint16 *sched;

   442

	uint order;

   443

	bool need_invalidate;

   444

   445

	FOR_ALL_VEHICLES(v) {

   446

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

   447

   448

			// clear last station visited

   449

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

   450

				v->last_station_visited = 0xFF;

   451

   452

			// check the next order

   453

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

   454

				v->next_order = OT_DUMMY;

   455

				InvalidateWindow(WC_VEHICLE_VIEW, v->index);

   456

			}

   457

   458

			// clear the order list

   459

			need_invalidate = false;

   460

			sched = v->schedule_ptr;

   461

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

   462

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

   463

					sched[-1] = OT_DUMMY;

   464

					need_invalidate = true;

   465

				}

   466

			}

   467

   468

			if (need_invalidate)

   469

				InvalidateWindow(WC_VEHICLE_ORDERS, v->index);

   470

		}

   471

	}

   472

}

   473

   474

void DoDeleteDepot(uint tile)

   475

{

   476

	byte dep_index;

   477

	Depot *d;

   478

   479

	// Clear it

   480

	DoClearSquare(tile);

   481

   482

	// Nullify the depot struct

   483

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

   484

	d->xy = 0;

   485

   486

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

   487

   488

	// Delete the depot

   489

	DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   490

}

   491

   492

void DeleteVehicle(Vehicle *v)

   493

{

   494

	DeleteName(v->string_id);

   495

	v->type = 0;

   496

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   497

	v->next_hash = 0xffff;

   498

   499

	if (v->schedule_ptr != NULL)

   500

		DeleteVehicleSchedule(v);

   501

}

   502

   503

void DeleteVehicleChain(Vehicle *v)

   504

{

   505

	do {

   506

		Vehicle *u = v;

   507

		v = v->next;

   508

		DeleteVehicle(u);

   509

	} while (v);

   510

}

   511

   512

   513

void Aircraft_Tick(Vehicle *v);

   514

void RoadVeh_Tick(Vehicle *v);

   515

void Ship_Tick(Vehicle *v);

   516

void Train_Tick(Vehicle *v);

   518

void DisasterVehicle_Tick(Vehicle *v);

   519

   520

VehicleTickProc *_vehicle_tick_procs[] = {

   521

	Train_Tick,

   522

	RoadVeh_Tick,

   523

	Ship_Tick,

   524

	Aircraft_Tick,