1

/* $Id$ */

     2

     3

/** @file station.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "bridge_map.h"

     8

#include "debug.h"

     9

#include "station_map.h"

    10

#include "station.h"

    11

#include "town.h"

    12

#include "news.h"

    13

#include "saveload.h"

    14

#include "player_func.h"

    15

#include "airport.h"

    16

#include "sprite.h"

    17

#include "depot.h"

    18

#include "train.h"

    19

#include "water_map.h"

    20

#include "industry_map.h"

    21

#include "newgrf_callbacks.h"

    22

#include "newgrf_station.h"

    23

#include "yapf/yapf.h"

    24

#include "cargotype.h"

    25

#include "roadveh.h"

    26

#include "station_gui.h"

    27

#include "zoom_func.h"

    28

#include "functions.h"

    29

#include "window_func.h"

    30

#include "date_func.h"

    31

#include "variables.h"

    32

    36

Station::Station(TileIndex tile)

    37

{

    38

	DEBUG(station, cDebugCtorLevel, "I+%3d", index);

    39

    40

	xy = tile;

    41

	airport_tile = dock_tile = train_tile = 0;

    42

	bus_stops = truck_stops = NULL;

    43

	had_vehicle_of_type = 0;

    44

	time_since_load = 255;

    45

	time_since_unload = 255;

    46

	delete_ctr = 0;

    47

	facilities = 0;

    48

    49

	last_vehicle_type = VEH_INVALID;

    50

    51

	random_bits = 0; // Random() must be called when station is really built (DC_EXEC)

    52

	waiting_triggers = 0;

    53

}

    54

    55

/**

    56

 * Clean up a station by clearing vehicle orders and invalidating windows.

    57

 * Aircraft-Hangar orders need special treatment here, as the hangars are

    58

 * actually part of a station (tiletype is STATION), but the order type

    59

 * is OT_GOTO_DEPOT.

    60

 */

    61

Station::~Station()

    62

{

    63

	DEBUG(station, cDebugCtorLevel, "I-%3d", index);

    64

    65

	free(this->name);

    66

	free(this->speclist);

    67

    68

	if (CleaningPool()) return;

    69

    70

	while (!loading_vehicles.empty()) {

    71

		loading_vehicles.front()->LeaveStation();

    72

	}

    73

    74

	MarkDirty();

    75

	RebuildStationLists();

    76

	InvalidateWindowClasses(WC_STATION_LIST);

    77

    78

	DeleteWindowById(WC_STATION_VIEW, index);

    79

    80

	/* Now delete all orders that go to the station */

    81

	RemoveOrderFromAllVehicles(OT_GOTO_STATION, index);

    82

    83

	/* Subsidies need removal as well */

    84

	DeleteSubsidyWithStation(index);

    85

    86

	xy = 0;

    87

    88

	for (CargoID c = 0; c < NUM_CARGO; c++) {

    89

		goods[c].cargo.Truncate(0);

    90

	}

    91

}

    92

    93

    94

/**

    95

 * Get the primary road stop (the first road stop) that the given vehicle can load/unload.

    96

 * @param v the vehicle to get the first road stop for

    97

 * @return the first roadstop that this vehicle can load at

    98

 */

    99

RoadStop *Station::GetPrimaryRoadStop(const Vehicle *v) const

   100

{

   101

	RoadStop *rs = this->GetPrimaryRoadStop(IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK);

   102

   103

	for (; rs != NULL; rs = rs->next) {

   104

		/* The vehicle cannot go to this roadstop (different roadtype) */

   105

		if ((GetRoadTypes(rs->xy) & v->u.road.compatible_roadtypes) == ROADTYPES_NONE) continue;

   106

		/* The vehicle is articulated and can therefor not go the a standard road stop */

   107

		if (IsStandardRoadStopTile(rs->xy) && RoadVehHasArticPart(v)) continue;

   108

   109

		/* The vehicle can actually go to this road stop. So, return it! */

   110

		break;

   111

	}

   112

   113

	return rs;

   114

}

   115

   116

/** Called when new facility is built on the station. If it is the first facility

   117

 * it initializes also 'xy' and 'random_bits' members */

   118

void Station::AddFacility(byte new_facility_bit, TileIndex facil_xy)

   119

{

   120

	if (facilities == 0) {

   121

		xy = facil_xy;

   122

		random_bits = Random();

   123

	}

   124

	facilities |= new_facility_bit;

   125

	owner = _current_player;

   126

	build_date = _date;

   127

}

   128

   129

void Station::MarkDirty() const

   130

{

   131

	if (sign.width_1 != 0) {

   132

		InvalidateWindowWidget(WC_STATION_VIEW, index, SVW_CAPTION);

   133

   134

		/* We use ZOOM_LVL_MAX here, as every viewport can have an other zoom,

   135

		 *  and there is no way for us to know which is the biggest. So make the

   136

		 *  biggest area dirty, and we are safe for sure. */

   137

		MarkAllViewportsDirty(

   138

			sign.left - 6,

   139

			sign.top,

   140

			sign.left + ScaleByZoom(sign.width_1 + 12, ZOOM_LVL_MAX),

   141

			sign.top + ScaleByZoom(12, ZOOM_LVL_MAX));

   142

	}

   143

}

   144

   145

void Station::MarkTilesDirty(bool cargo_change) const

   146

{

   147

	TileIndex tile = train_tile;

   148

	int w, h;

   149

   150

	/* XXX No station is recorded as 0, not INVALID_TILE... */

   151

	if (tile == 0) return;

   152

   153

	/* cargo_change is set if we're refreshing the tiles due to cargo moving

   154

	 * around. */

   155

	if (cargo_change) {

   156

		/* Don't waste time updating if there are no custom station graphics

   157

		 * that might change. Even if there are custom graphics, they might

   158

		 * not change. Unfortunately we have no way of telling. */

   159

		if (this->num_specs == 0) return;

   160

	}

   161

   162

	for (h = 0; h < trainst_h; h++) {

   163

		for (w = 0; w < trainst_w; w++) {

   164

			if (TileBelongsToRailStation(tile)) {

   165

				MarkTileDirtyByTile(tile);

   166

			}

   167

			tile += TileDiffXY(1, 0);

   168

		}

   169

		tile += TileDiffXY(-w, 1);

   170

	}

   171

}

   172

   173

bool Station::TileBelongsToRailStation(TileIndex tile) const

   174

{

   175

	return IsTileType(tile, MP_STATION) && GetStationIndex(tile) == index && IsRailwayStation(tile);

   176

}

   177

   178

/** Obtain the length of a platform

   179

 * @pre tile must be a railway station tile

   180

 * @param tile A tile that contains the platform in question

   181

 * @return The length of the platform

   182

 */

   183

uint Station::GetPlatformLength(TileIndex tile) const

   184

{

   185

	TileIndex t;

   186

	TileIndexDiff delta;

   187

	uint len = 0;

   188

	assert(TileBelongsToRailStation(tile));

   189

   190

	delta = (GetRailStationAxis(tile) == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));

   191

   192

	t = tile;

   193

	do {

   194

		t -= delta;

   195

		len++;

   196

	} while (IsCompatibleTrainStationTile(t, tile));

   197

   198

	t = tile;

   199

	do {

   200

		t += delta;

   201

		len++;

   202

	} while (IsCompatibleTrainStationTile(t, tile));

   203

   204

	return len - 1;

   205

}

   206

   207

/** Determines the REMAINING length of a platform, starting at (and including)

   208

 * the given tile.

   209

 * @param tile the tile from which to start searching. Must be a railway station tile

   210

 * @param dir The direction in which to search.

   211

 * @return The platform length

   212

 */

   213

uint Station::GetPlatformLength(TileIndex tile, DiagDirection dir) const

   214

{

   215

	TileIndex start_tile = tile;

   216

	uint length = 0;

   217

	assert(IsRailwayStationTile(tile));

   218

	assert(dir < DIAGDIR_END);

   219

   220

	do {

   221

		length ++;

   222

		tile += TileOffsByDiagDir(dir);

   223

	} while (IsCompatibleTrainStationTile(tile, start_tile));

   224

   225

	return length;

   226

}

   227

   228

/** Determines whether a station is a buoy only.

   229

 * @todo Ditch this encoding of buoys

   230

 */

   231

bool Station::IsBuoy() const

   232

{

   233

	return (had_vehicle_of_type & HVOT_BUOY) != 0;

   234

}

   235

   236

   237

/************************************************************************/

   238

/*                     StationRect implementation                       */

   239

/************************************************************************/

   240

   241

StationRect::StationRect()

   242

{

   243

	MakeEmpty();

   244

}

   245

   246

void StationRect::MakeEmpty()

   247

{

   248

	left = top = right = bottom = 0;

   249

}

   250

   251

/**

   252

 * Determines whether a given point (x, y) is within a certain distance of

   253

 * the station rectangle.

   254

 * @note x and y are in Tile coordinates

   255

 * @param x X coordinate

   256

 * @param y Y coordinate

   257

 * @param distance The maxmium distance a point may have (L1 norm)

   258

 * @return true if the point is within distance tiles of the station rectangle

   259

 */

   260

bool StationRect::PtInExtendedRect(int x, int y, int distance) const

   261

{

   262

	return (left - distance <= x && x <= right + distance && top - distance <= y && y <= bottom + distance);

   263

}

   264

   265

bool StationRect::IsEmpty() const

   266

{

   267

	return (left == 0 || left > right || top > bottom);

   268

}

   269

   270

bool StationRect::BeforeAddTile(TileIndex tile, StationRectMode mode)

   271

{

   272

	int x = TileX(tile);

   273

	int y = TileY(tile);

   274

	if (IsEmpty()) {

   275

		/* we are adding the first station tile */

   276

		left = right = x;

   277

		top = bottom = y;

   278

   279

	} else if (!PtInExtendedRect(x, y)) {

   280

		/* current rect is not empty and new point is outside this rect */

   281

		/* make new spread-out rectangle */

   282

		Rect new_rect = {min(x, left), min(y, top), max(x, right), max(y, bottom)};

   283

   284

		/* check new rect dimensions against preset max */

   285

		int w = new_rect.right - new_rect.left + 1;

   286

		int h = new_rect.bottom - new_rect.top + 1;

   287

		if (mode != ADD_FORCE && (w > _patches.station_spread || h > _patches.station_spread)) {

   288

			assert(mode != ADD_TRY);

   289

			_error_message = STR_306C_STATION_TOO_SPREAD_OUT;

   290

			return false;

   291

		}

   292

   293

		/* spread-out ok, return true */

   294

		if (mode != ADD_TEST) {

   295

			/* we should update the station rect */

   296

			*this = new_rect;

   297

		}

   298

	} else {

   299

		; // new point is inside the rect, we don't need to do anything

   300

	}

   301

	return true;

   302

}

   303

   304

bool StationRect::BeforeAddRect(TileIndex tile, int w, int h, StationRectMode mode)

   305

{

   306

	return BeforeAddTile(tile, mode) && BeforeAddTile(TILE_ADDXY(tile, w - 1, h - 1), mode);

   307

}

   308

   309

/*static*/ bool StationRect::ScanForStationTiles(StationID st_id, int left_a, int top_a, int right_a, int bottom_a)

   310

{

   311

	TileIndex top_left = TileXY(left_a, top_a);

   312

	int width = right_a - left_a + 1;

   313

	int height = bottom_a - top_a + 1;

   314

   315

	BEGIN_TILE_LOOP(tile, width, height, top_left)

   316

		if (IsTileType(tile, MP_STATION) && GetStationIndex(tile) == st_id) return true;

   317

	END_TILE_LOOP(tile, width, height, top_left);

   318

   319

	return false;

   320

}

   321

   322

bool StationRect::AfterRemoveTile(Station *st, TileIndex tile)

   323

{

   324

	int x = TileX(tile);

   325

	int y = TileY(tile);

   326

   327

	/* look if removed tile was on the bounding rect edge

   328

	 * and try to reduce the rect by this edge

   329

	 * do it until we have empty rect or nothing to do */

   330

	for (;;) {

   331

		/* check if removed tile is on rect edge */

   332

		bool left_edge = (x == left);

   333

		bool right_edge = (x == right);

   334

		bool top_edge = (y == top);

   335

		bool bottom_edge = (y == bottom);

   336

   337

		/* can we reduce the rect in either direction? */

   338

		bool reduce_x = ((left_edge || right_edge) && !ScanForStationTiles(st->index, x, top, x, bottom));

   339

		bool reduce_y = ((top_edge || bottom_edge) && !ScanForStationTiles(st->index, left, y, right, y));

   340

		if (!(reduce_x || reduce_y)) break; // nothing to do (can't reduce)

   341

   342

		if (reduce_x) {

   343

			/* reduce horizontally */

   344

			if (left_edge) {

   345

				/* move left edge right */

   346

				left = x = x + 1;

   347

			} else {

   348

				/* move right edge left */

   349

				right = x = x - 1;

   350

			}

   351

		}

   352

		if (reduce_y) {

   353

			/* reduce vertically */

   354

			if (top_edge) {

   355

				/* move top edge down */

   356

				top = y = y + 1;

   357

			} else {

   358

				/* move bottom edge up */

   359

				bottom = y = y - 1;

   360

			}

   361

		}

   362

   363

		if (left > right || top > bottom) {

   364

			/* can't continue, if the remaining rectangle is empty */

   365

			MakeEmpty();

   366

			return true; // empty remaining rect

   367

		}

   368

	}

   369

	return false; // non-empty remaining rect

   370

}

   371

   372

bool StationRect::AfterRemoveRect(Station *st, TileIndex tile, int w, int h)

   373

{

   374

	assert(PtInExtendedRect(TileX(tile), TileY(tile)));

   375

	assert(PtInExtendedRect(TileX(tile) + w - 1, TileY(tile) + h - 1));

   376

   377

	bool empty = AfterRemoveTile(st, tile);

   378

	if (w != 1 || h != 1) empty = empty || AfterRemoveTile(st, TILE_ADDXY(tile, w - 1, h - 1));

   379

	return empty;

   380

}

   381

   382

StationRect& StationRect::operator = (Rect src)

   383

{

   384

	left = src.left;

   385

	top = src.top;

   386

	right = src.right;

   387

	bottom = src.bottom;

   388

	return *this;

   389

}

   390

   391

   392

/************************************************************************/

   393

/*                     RoadStop implementation                          */

   394

/************************************************************************/

   395

   396

/** Initializes a RoadStop */

   397

RoadStop::RoadStop(TileIndex tile) :

   398

	xy(tile),

   399

	status(3), // stop is free

   400

	num_vehicles(0),

   401

	next(NULL)

   402

{

   403

	DEBUG(ms, cDebugCtorLevel,  "I+ at %d[0x%x]", tile, tile);

   404

}

   405

   406

/** De-Initializes a RoadStops. This includes clearing all slots that vehicles might

   407

  * have and unlinks it from the linked list of road stops at the given station

   408

  */

   409

RoadStop::~RoadStop()

   410

{

   411

	if (CleaningPool()) return;

   412

   413

	/* Clear the slot assignment of all vehicles heading for this road stop */

   414

	if (num_vehicles != 0) {

   415

		Vehicle *v;

   416

   417

		FOR_ALL_VEHICLES(v) {

   418

			if (v->type == VEH_ROAD && v->u.road.slot == this) ClearSlot(v);

   419

		}

   420

	}

   421

	assert(num_vehicles == 0);

   422

   423

	DEBUG(ms, cDebugCtorLevel , "I- at %d[0x%x]", xy, xy);

   424

   425

	xy = 0;

   426

}

   427

   428

/** Checks whether there is a free bay in this road stop */

   429

bool RoadStop::HasFreeBay() const

   430

{

   431

	return GB(status, 0, MAX_BAY_COUNT) != 0;

   432

}

   433

   434

/** Checks whether the given bay is free in this road stop */

   435

bool RoadStop::IsFreeBay(uint nr) const

   436

{

   437

	assert(nr < MAX_BAY_COUNT);

   438

	return HasBit(status, nr);

   439

}

   440

   441

/**

   442

 * Allocates a bay

   443

 * @return the allocated bay number

   444

 * @pre this->HasFreeBay()

   445

 */

   446

uint RoadStop::AllocateBay()

   447

{

   448

	assert(HasFreeBay());

   449

   450

	/* Find the first free bay. If the bit is set, the bay is free. */

   451

	uint bay_nr = 0;

   452

	while (!HasBit(status, bay_nr)) bay_nr++;

   453

   454

	ClrBit(status, bay_nr);

   455

	return bay_nr;

   456

}

   457

   458

/**

   459

 * Allocates a bay in a drive-through road stop

   460

 * @param nr the number of the bay to allocate

   461

 */

   462

void RoadStop::AllocateDriveThroughBay(uint nr)

   463

{

   464

	assert(nr < MAX_BAY_COUNT);

   465

	ClrBit(status, nr);

   466

}

   467

   468

/**

   469

 * Frees the given bay

   470

 * @param nr the number of the bay to free

   471

 */

   472

void RoadStop::FreeBay(uint nr)

   473

{

   474

	assert(nr < MAX_BAY_COUNT);

   475

	SetBit(status, nr);

   476

}

   477

   478

   479

/** Checks whether the entrance of the road stop is occupied by a vehicle */

   480

bool RoadStop::IsEntranceBusy() const

   481

{

   482

	return HasBit(status, 7);

   483

}

   484

   485

/** Makes an entrance occupied or free */

   486

void RoadStop::SetEntranceBusy(bool busy)

   487