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_base.h"

    11

#include "town.h"

    12

#include "saveload.h"

    13

#include "player_func.h"

    14

#include "airport.h"

    15

#include "sprite.h"

    16

#include "depot.h"

    17

#include "train.h"

    18

#include "water_map.h"

    19

#include "industry_map.h"

    20

#include "newgrf_callbacks.h"

    21

#include "newgrf_station.h"

    22

#include "yapf/yapf.h"

    23

#include "cargotype.h"

    24

#include "roadveh.h"

    25

#include "station_gui.h"

    26

#include "zoom_func.h"

    27

#include "functions.h"

    28

#include "window_func.h"

    29

#include "date_func.h"

    30

#include "variables.h"

    31

#include "settings_type.h"

    32

#include "command_func.h"

    33

#include "order_func.h"

    34

    35

#include "table/sprites.h"

    36

#include "table/strings.h"

    37

    38

Station::Station(TileIndex tile)

    39

{

    40

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

    41

    42

	xy = tile;

    43

	airport_tile = dock_tile = train_tile = 0;

    44

	bus_stops = truck_stops = NULL;

    45

	had_vehicle_of_type = 0;

    46

	time_since_load = 255;

    47

	time_since_unload = 255;

    48

	delete_ctr = 0;

    49

	facilities = 0;

    50

    51

	last_vehicle_type = VEH_INVALID;

    52

    53

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

    54

	waiting_triggers = 0;

    55

}

    56

    57

/**

    58

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

    59

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

    60

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

    61

 * is OT_GOTO_DEPOT.

    62

 */

    63

Station::~Station()

    64

{

    65

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

    66

    67

	free(this->name);

    68

	free(this->speclist);

    69

    70

	if (CleaningPool()) return;

    71

    72

	while (!loading_vehicles.empty()) {

    73

		loading_vehicles.front()->LeaveStation();

    74

	}

    75

    76

	MarkDirty();

    77

	RebuildStationLists();

    78

	InvalidateWindowClasses(WC_STATION_LIST);

    79

    80

	DeleteWindowById(WC_STATION_VIEW, index);

    81

    82

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

    83

	RemoveOrderFromAllVehicles(OT_GOTO_STATION, index);

    84

    85

	/* Subsidies need removal as well */

    86

	DeleteSubsidyWithStation(index);

    87

    88

	xy = 0;

    89

    90

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

    91

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

    92

	}

    93

}

    94

    95

    96

/**

    97

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

    98

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

    99

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

   100

 */

   101

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

   102

{

   103

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

   104

   105

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

   106

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

   107

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

   108

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

   109

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

   110

   111

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

   112

		break;

   113

	}

   114

   115

	return rs;

   116

}

   117

   118

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

   119

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

   120

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

   121

{

   122

	if (facilities == 0) {

   123

		xy = facil_xy;

   124

		random_bits = Random();

   125

	}

   126

	facilities |= new_facility_bit;

   127

	owner = _current_player;

   128

	build_date = _date;

   129

}

   130

   131

void Station::MarkDirty() const

   132

{

   133

	if (sign.width_1 != 0) {

   134

		InvalidateWindowWidget(WC_STATION_VIEW, index, SVW_CAPTION);

   135

   136

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

   137

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

   138

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

   139

		MarkAllViewportsDirty(

   140

			sign.left - 6,

   141

			sign.top,

   142

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

   143

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

   144

	}

   145

}

   146

   147

void Station::MarkTilesDirty(bool cargo_change) const

   148

{

   149

	TileIndex tile = train_tile;

   150

	int w, h;

   151

   152

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

   153

	if (tile == 0) return;

   154

   155

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

   156

	 * around. */

   157

	if (cargo_change) {

   158

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

   159

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

   160

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

   161

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

   162

	}

   163

   164

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

   165

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

   166

			if (TileBelongsToRailStation(tile)) {

   167

				MarkTileDirtyByTile(tile);

   168

			}

   169

			tile += TileDiffXY(1, 0);

   170

		}

   171

		tile += TileDiffXY(-w, 1);

   172

	}

   173

}

   174

   175

bool Station::TileBelongsToRailStation(TileIndex tile) const

   176

{

   177

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

   178

}

   179

   180

/** Obtain the length of a platform

   181

 * @pre tile must be a railway station tile

   182

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

   183

 * @return The length of the platform

   184

 */

   185

uint Station::GetPlatformLength(TileIndex tile) const

   186

{

   187

	TileIndex t;

   188

	TileIndexDiff delta;

   189

	uint len = 0;

   190

	assert(TileBelongsToRailStation(tile));

   191

   192

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

   193

   194

	t = tile;

   195

	do {

   196

		t -= delta;

   197

		len++;

   198

	} while (IsCompatibleTrainStationTile(t, tile));

   199

   200

	t = tile;

   201

	do {

   202

		t += delta;

   203

		len++;

   204

	} while (IsCompatibleTrainStationTile(t, tile));

   205

   206

	return len - 1;

   207

}

   208

   209

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

   210

 * the given tile.

   211

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

   212

 * @param dir The direction in which to search.

   213

 * @return The platform length

   214

 */

   215

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

   216

{

   217

	TileIndex start_tile = tile;

   218

	uint length = 0;

   219

	assert(IsRailwayStationTile(tile));

   220

	assert(dir < DIAGDIR_END);

   221

   222

	do {

   223

		length ++;

   224

		tile += TileOffsByDiagDir(dir);

   225

	} while (IsCompatibleTrainStationTile(tile, start_tile));

   226

   227

	return length;

   228

}

   229

   230

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

   231

 * @todo Ditch this encoding of buoys

   232

 */

   233

bool Station::IsBuoy() const

   234

{

   235

	return (had_vehicle_of_type & HVOT_BUOY) != 0;

   236

}

   237

   238

   239

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

   240

/*                     StationRect implementation                       */

   241

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

   242

   243

StationRect::StationRect()

   244

{

   245

	MakeEmpty();

   246

}

   247

   248

void StationRect::MakeEmpty()

   249

{

   250

	left = top = right = bottom = 0;

   251

}

   252

   253

/**

   254

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

   255

 * the station rectangle.

   256

 * @note x and y are in Tile coordinates

   257

 * @param x X coordinate

   258

 * @param y Y coordinate

   259

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

   260

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

   261

 */

   262

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

   263

{

   264

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

   265

}

   266

   267

bool StationRect::IsEmpty() const

   268

{

   269

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

   270

}

   271

   272

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

   273

{

   274

	int x = TileX(tile);

   275

	int y = TileY(tile);

   276

	if (IsEmpty()) {

   277

		/* we are adding the first station tile */

   278

		left = right = x;

   279

		top = bottom = y;

   280

   281

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

   282

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

   283

		/* make new spread-out rectangle */

   284

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

   285

   286

		/* check new rect dimensions against preset max */

   287

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

   288

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

   289

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

   290

			assert(mode != ADD_TRY);

   291

			_error_message = STR_306C_STATION_TOO_SPREAD_OUT;

   292

			return false;

   293

		}

   294

   295

		/* spread-out ok, return true */

   296

		if (mode != ADD_TEST) {

   297

			/* we should update the station rect */

   298

			*this = new_rect;

   299

		}

   300

	} else {

   301

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

   302

	}

   303

	return true;

   304

}

   305

   306

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

   307

{

   308

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

   309

}

   310

   311

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

   312

{

   313

	TileIndex top_left = TileXY(left_a, top_a);

   314

	int width = right_a - left_a + 1;

   315

	int height = bottom_a - top_a + 1;

   316

   317

	BEGIN_TILE_LOOP(tile, width, height, top_left)

   318

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

   319

	END_TILE_LOOP(tile, width, height, top_left);

   320

   321

	return false;

   322

}

   323

   324

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

   325

{

   326

	int x = TileX(tile);

   327

	int y = TileY(tile);

   328

   329

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

   330

	 * and try to reduce the rect by this edge

   331

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

   332

	for (;;) {

   333

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

   334

		bool left_edge = (x == left);

   335

		bool right_edge = (x == right);

   336

		bool top_edge = (y == top);

   337

		bool bottom_edge = (y == bottom);

   338

   339

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

   340

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

   341

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

   342

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

   343

   344

		if (reduce_x) {

   345

			/* reduce horizontally */

   346

			if (left_edge) {

   347

				/* move left edge right */

   348

				left = x = x + 1;

   349

			} else {

   350

				/* move right edge left */

   351

				right = x = x - 1;

   352

			}

   353

		}

   354

		if (reduce_y) {

   355

			/* reduce vertically */

   356

			if (top_edge) {

   357

				/* move top edge down */

   358

				top = y = y + 1;

   359

			} else {

   360

				/* move bottom edge up */

   361

				bottom = y = y - 1;

   362

			}

   363

		}

   364

   365

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

   366

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

   367

			MakeEmpty();

   368

			return true; // empty remaining rect

   369

		}

   370

	}

   371

	return false; // non-empty remaining rect

   372

}

   373

   374

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

   375

{

   376

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

   377

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

   378

   379

	bool empty = AfterRemoveTile(st, tile);

   380

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

   381

	return empty;

   382

}

   383

   384

StationRect& StationRect::operator = (Rect src)

   385

{

   386

	left = src.left;

   387

	top = src.top;

   388

	right = src.right;

   389

	bottom = src.bottom;

   390

	return *this;

   391

}

   392

   393

   394

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

   395

/*                     RoadStop implementation                          */

   396

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

   397

   398

/** Initializes a RoadStop */

   399

RoadStop::RoadStop(TileIndex tile) :

   400

	xy(tile),

   401

	status(3), // stop is free

   402

	num_vehicles(0),

   403

	next(NULL)

   404

{

   405

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

   406

}

   407

   408

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

   409

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

   410

  */

   411

RoadStop::~RoadStop()

   412

{

   413

	if (CleaningPool()) return;

   414

   415

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

   416

	if (num_vehicles != 0) {

   417

		Vehicle *v;

   418

   419

		FOR_ALL_VEHICLES(v) {

   420

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

   421

		}

   422

	}

   423

	assert(num_vehicles == 0);

   424

   425

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

   426

   427

	xy = 0;

   428

}

   429

   430

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

   431

bool RoadStop::HasFreeBay() const

   432

{

   433

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

   434

}

   435

   436

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

   437

bool RoadStop::IsFreeBay(uint nr) const

   438

{

   439

	assert(nr < MAX_BAY_COUNT);

   440

	return HasBit(status, nr);

   441

}

   442

   443

/**

   444

 * Allocates a bay

   445

 * @return the allocated bay number

   446

 * @pre this->HasFreeBay()

   447

 */

   448

uint RoadStop::AllocateBay()

   449

{

   450

	assert(HasFreeBay());

   451

   452

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

   453

	uint bay_nr = 0;

   454

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

   455

   456

	ClrBit(status, bay_nr);

   457

	return bay_nr;

   458

}

   459

   460

/**

   461

 * Allocates a bay in a drive-through road stop

   462

 * @param nr the number of the bay to allocate

   463

 */

   464

void RoadStop::AllocateDriveThroughBay(uint nr)

   465

{

   466

	assert(nr < MAX_BAY_COUNT);

   467

	ClrBit(status, nr);

   468

}

   469

   470

/**

   471

 * Frees the given bay

   472

 * @param nr the number of the bay to free

   473

 */

   474

void RoadStop::FreeBay(uint nr)

   475

{

   476

	assert(nr < MAX_BAY_COUNT);

   477

	SetBit(status, nr);

   478

}

   479

   480

   481

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

   482

bool RoadStop::IsEntranceBusy() const

   483

{

   484

	return HasBit(status, 7);

   485

}

   486