1

/* $Id$ */

     2

     3

/** @file station_cmd.cpp Handling of station tiles. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "aircraft.h"

     8

#include "bridge_map.h"

     9

#include "cmd_helper.h"

    10

#include "debug.h"

    11

#include "tile_cmd.h"

    12

#include "landscape.h"

    13

#include "station_map.h"

    14

#include "viewport_func.h"

    15

#include "command_func.h"

    16

#include "town.h"

    17

#include "news_func.h"

    18

#include "saveload.h"

    19

#include "airport.h"

    20

#include "sprite.h"

    21

#include "train.h"

    22

#include "roadveh.h"

    23

#include "water_map.h"

    24

#include "industry_map.h"

    25

#include "newgrf_callbacks.h"

    26

#include "newgrf_station.h"

    27

#include "yapf/yapf.h"

    28

#include "road_type.h"

    29

#include "road_internal.h" /* For drawing catenary/checking road removal */

    30

#include "cargotype.h"

    31

#include "variables.h"

    32

#include "autoslope.h"

    33

#include "transparency.h"

    34

#include "water.h"

    35

#include "station_gui.h"

    36

#include "strings_func.h"

    37

#include "functions.h"

    38

#include "window_func.h"

    39

#include "date_func.h"

    40

#include "vehicle_func.h"

    41

#include "string_func.h"

    42

#include "signal_func.h"

    43

#include "oldpool_func.h"

    44

#include "animated_tile_func.h"

    45

#include "elrail_func.h"

    46

#include "newgrf.h"

    47

#include "core/smallvec_type.hpp"

    48

    49

#include "table/sprites.h"

    50

#include "table/strings.h"

    51

    52

DEFINE_OLD_POOL_GENERIC(Station, Station)

    53

DEFINE_OLD_POOL_GENERIC(RoadStop, RoadStop)

    54

    55

    56

/**

    57

 * Check whether the given tile is a hangar.

    58

 * @param t the tile to of whether it is a hangar.

    59

 * @pre IsTileType(t, MP_STATION)

    60

 * @return true if and only if the tile is a hangar.

    61

 */

    62

bool IsHangar(TileIndex t)

    63

{

    64

	assert(IsTileType(t, MP_STATION));

    65

    66

	const Station *st = GetStationByTile(t);

    67

	const AirportFTAClass *apc = st->Airport();

    68

    69

	for (uint i = 0; i < apc->nof_depots; i++) {

    70

		if (st->airport_tile + ToTileIndexDiff(apc->airport_depots[i]) == t) return true;

    71

	}

    72

    73

	return false;

    74

}

    75

    76

RoadStop *GetRoadStopByTile(TileIndex tile, RoadStopType type)

    77

{

    78

	const Station *st = GetStationByTile(tile);

    79

    80

	for (RoadStop *rs = st->GetPrimaryRoadStop(type);; rs = rs->next) {

    81

		if (rs->xy == tile) return rs;

    82

		assert(rs->next != NULL);

    83

	}

    84

}

    85

    86

    87

static uint GetNumRoadStopsInStation(const Station *st, RoadStopType type)

    88

{

    89

	uint num = 0;

    90

    91

	assert(st != NULL);

    92

	for (const RoadStop *rs = st->GetPrimaryRoadStop(type); rs != NULL; rs = rs->next) {

    93

		num++;

    94

	}

    95

    96

	return num;

    97

}

    98

    99

   100

/** Calculate the radius of the station. Basicly it is the biggest

   101

 *  radius that is available within the station

   102

 * @param st Station to query

   103

 * @return the so calculated radius

   104

 */

   105

static uint FindCatchmentRadius(const Station *st)

   106

{

   107

	uint ret = CA_NONE;

   108

   109

	if (st->bus_stops   != NULL) ret = max<uint>(ret, CA_BUS);

   110

	if (st->truck_stops != NULL) ret = max<uint>(ret, CA_TRUCK);

   111

	if (st->train_tile  != 0)    ret = max<uint>(ret, CA_TRAIN);

   112

	if (st->dock_tile   != 0)    ret = max<uint>(ret, CA_DOCK);

   113

	if (st->airport_tile)        ret = max<uint>(ret, st->Airport()->catchment);

   114

   115

	return ret;

   116

}

   117

   118

#define CHECK_STATIONS_ERR ((Station*)-1)

   119

   120

static Station *GetStationAround(TileIndex tile, int w, int h, StationID closest_station)

   121

{

   122

	/* check around to see if there's any stations there */

   123

	BEGIN_TILE_LOOP(tile_cur, w + 2, h + 2, tile - TileDiffXY(1, 1))

   124

		if (IsTileType(tile_cur, MP_STATION)) {

   125

			StationID t = GetStationIndex(tile_cur);

   126

   127

			if (closest_station == INVALID_STATION) {

   128

				closest_station = t;

   129

			} else if (closest_station != t) {

   130

				_error_message = STR_3006_ADJOINS_MORE_THAN_ONE_EXISTING;

   131

				return CHECK_STATIONS_ERR;

   132

			}

   133

		}

   134

	END_TILE_LOOP(tile_cur, w + 2, h + 2, tile - TileDiffXY(1, 1))

   135

	return (closest_station == INVALID_STATION) ? NULL : GetStation(closest_station);

   136

}

   137

   138

/**

   139

 * Function to check whether the given tile matches some criterion.

   140

 * @param tile the tile to check

   141

 * @return true if it matches, false otherwise

   142

 */

   143

typedef bool (*CMSAMatcher)(TileIndex tile);

   144

   145

/**

   146

 * Counts the numbers of tiles matching a specific type in the area around

   147

 * @param tile the center tile of the 'count area'

   148

 * @param type the type of tile searched for

   149

 * @param industry when type == MP_INDUSTRY, the type of the industry,

   150

 *                 in all other cases this parameter is ignored

   151

 * @return the result the noumber of matching tiles around

   152

 */

   153

static int CountMapSquareAround(TileIndex tile, CMSAMatcher cmp)

   154

{

   155

	int num = 0;

   156

   157

	for (int dx = -3; dx <= 3; dx++) {

   158

		for (int dy = -3; dy <= 3; dy++) {

   159

			if (cmp(TILE_MASK(tile + TileDiffXY(dx, dy)))) num++;

   160

		}

   161

	}

   162

   163

	return num;

   164

}

   165

   166

/**

   167

 * Check whether the tile is a mine.

   168

 * @param tile the tile to investigate.

   169

 * @return true if and only if the tile is a mine

   170

 */

   171

static bool CMSAMine(TileIndex tile)

   172

{

   173

	/* No industry */

   174

	if (!IsTileType(tile, MP_INDUSTRY)) return false;

   175

   176

	const Industry *ind = GetIndustryByTile(tile);

   177

   178

	/* No extractive industry */

   179

	if ((GetIndustrySpec(ind->type)->life_type & INDUSTRYLIFE_EXTRACTIVE) == 0) return false;

   180

   181

	for (uint i = 0; i < lengthof(ind->produced_cargo); i++) {

   182

		/* The industry extracts something non-liquid, i.e. no oil or plastic, so it is a mine */

   183

		if (ind->produced_cargo[i] != CT_INVALID && (GetCargo(ind->produced_cargo[i])->classes & CC_LIQUID) == 0) return true;

   184

	}

   185

   186

	return false;

   187

}

   188

   189

/**

   190

 * Check whether the tile is water.

   191

 * @param tile the tile to investigate.

   192

 * @return true if and only if the tile is a mine

   193

 */

   194

static bool CMSAWater(TileIndex tile)

   195

{

   196

	return IsTileType(tile, MP_WATER) && IsWater(tile);

   197

}

   198

   199

/**

   200

 * Check whether the tile is a tree.

   201

 * @param tile the tile to investigate.

   202

 * @return true if and only if the tile is a mine

   203

 */

   204

static bool CMSATree(TileIndex tile)

   205

{

   206

	return IsTileType(tile, MP_TREES);

   207

}

   208

   209

/**

   210

 * Check whether the tile is a forest.

   211

 * @param tile the tile to investigate.

   212

 * @return true if and only if the tile is a mine

   213

 */

   214

static bool CMSAForest(TileIndex tile)

   215

{

   216

	/* No industry */

   217

	if (!IsTileType(tile, MP_INDUSTRY)) return false;

   218

   219

	const Industry *ind = GetIndustryByTile(tile);

   220

   221

	/* No extractive industry */

   222

	if ((GetIndustrySpec(ind->type)->life_type & INDUSTRYLIFE_ORGANIC) == 0) return false;

   223

   224

	for (uint i = 0; i < lengthof(ind->produced_cargo); i++) {

   225

		/* The industry produces wood. */

   226

		if (ind->produced_cargo[i] != CT_INVALID && GetCargo(ind->produced_cargo[i])->label == 'WOOD') return true;

   227

	}

   228

   229

	return false;

   230

}

   231

   232

#define M(x) ((x) - STR_SV_STNAME)

   233

   234

enum StationNaming {

   235

	STATIONNAMING_RAIL = 0,

   236

	STATIONNAMING_ROAD = 0,

   237

	STATIONNAMING_AIRPORT,

   238

	STATIONNAMING_OILRIG,

   239

	STATIONNAMING_DOCK,

   240

	STATIONNAMING_BUOY,

   241

	STATIONNAMING_HELIPORT,

   242

};

   243

   244

static StringID GenerateStationName(Station *st, TileIndex tile, int flag)

   245

{

   246

	static const uint32 _gen_station_name_bits[] = {

   247

		0,                                      /* 0 */

   248

		1 << M(STR_SV_STNAME_AIRPORT),          /* 1 */

   249

		1 << M(STR_SV_STNAME_OILFIELD),         /* 2 */

   250

		1 << M(STR_SV_STNAME_DOCKS),            /* 3 */

   251

		0x1FF << M(STR_SV_STNAME_BUOY_1),       /* 4 */

   252

		1 << M(STR_SV_STNAME_HELIPORT),         /* 5 */

   253

	};

   254

   255

	const Town *t = st->town;

   256

	uint32 free_names = UINT32_MAX;

   257

   258

	const Station *s;

   259

	FOR_ALL_STATIONS(s) {

   260

		if (s != st && s->town == t) {

   261

			uint str = M(s->string_id);

   262

			if (str <= 0x20) {

   263

				if (str == M(STR_SV_STNAME_FOREST)) {

   264

					str = M(STR_SV_STNAME_WOODS);

   265

				}

   266

				ClrBit(free_names, str);

   267

			}

   268

		}

   269

	}

   270

   271

	/* check default names */

   272

	uint32 tmp = free_names & _gen_station_name_bits[flag];

   273

	if (tmp != 0) return STR_SV_STNAME + FindFirstBit(tmp);

   274

   275

	/* check mine? */

   276

	if (HasBit(free_names, M(STR_SV_STNAME_MINES))) {

   277

		if (CountMapSquareAround(tile, CMSAMine) >= 2) {

   278

			return STR_SV_STNAME_MINES;

   279

		}

   280

	}

   281

   282

	/* check close enough to town to get central as name? */

   283

	if (DistanceMax(tile, t->xy) < 8) {

   284

		if (HasBit(free_names, M(STR_SV_STNAME))) return STR_SV_STNAME;

   285

   286

		if (HasBit(free_names, M(STR_SV_STNAME_CENTRAL))) return STR_SV_STNAME_CENTRAL;

   287

	}

   288

   289

	/* Check lakeside */

   290

	if (HasBit(free_names, M(STR_SV_STNAME_LAKESIDE)) &&

   291

			DistanceFromEdge(tile) < 20 &&

   292

			CountMapSquareAround(tile, CMSAWater) >= 5) {

   293

		return STR_SV_STNAME_LAKESIDE;

   294

	}

   295

   296

	/* Check woods */

   297

	if (HasBit(free_names, M(STR_SV_STNAME_WOODS)) && (

   298

				CountMapSquareAround(tile, CMSATree) >= 8 ||

   299

				CountMapSquareAround(tile, CMSAForest) >= 2)

   300

			) {

   301

		return _settings_game.game_creation.landscape == LT_TROPIC ? STR_SV_STNAME_FOREST : STR_SV_STNAME_WOODS;

   302

	}

   303

   304

	/* check elevation compared to town */

   305

	uint z = GetTileZ(tile);

   306

	uint z2 = GetTileZ(t->xy);

   307

	if (z < z2) {

   308

		if (HasBit(free_names, M(STR_SV_STNAME_VALLEY))) return STR_SV_STNAME_VALLEY;

   309

	} else if (z > z2) {

   310

		if (HasBit(free_names, M(STR_SV_STNAME_HEIGHTS))) return STR_SV_STNAME_HEIGHTS;

   311

	}

   312

   313

	/* check direction compared to town */

   314

	static const int8 _direction_and_table[] = {

   315

		~( (1 << M(STR_SV_STNAME_WEST))  | (1 << M(STR_SV_STNAME_EAST)) | (1 << M(STR_SV_STNAME_NORTH)) ),

   316

		~( (1 << M(STR_SV_STNAME_SOUTH)) | (1 << M(STR_SV_STNAME_WEST)) | (1 << M(STR_SV_STNAME_NORTH)) ),

   317

		~( (1 << M(STR_SV_STNAME_SOUTH)) | (1 << M(STR_SV_STNAME_EAST)) | (1 << M(STR_SV_STNAME_NORTH)) ),

   318

		~( (1 << M(STR_SV_STNAME_SOUTH)) | (1 << M(STR_SV_STNAME_WEST)) | (1 << M(STR_SV_STNAME_EAST)) ),

   319

	};

   320

   321

	free_names &= _direction_and_table[

   322

		(TileX(tile) < TileX(t->xy)) +

   323

		(TileY(tile) < TileY(t->xy)) * 2];

   324

   325

	tmp = free_names & ((1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 6) | (1 << 7) | (1 << 12) | (1 << 26) | (1 << 27) | (1 << 28) | (1 << 29) | (1 << 30));

   326

	return (tmp == 0) ? STR_SV_STNAME_FALLBACK : (STR_SV_STNAME + FindFirstBit(tmp));

   327

}

   328

#undef M

   329

   330

static Station *GetClosestStationFromTile(TileIndex tile)

   331

{

   332

	uint threshold = 8;

   333

	Station *best_station = NULL;

   334

	Station *st;

   335

   336

	FOR_ALL_STATIONS(st) {

   337

		if (st->facilities == 0 && st->owner == _current_player) {

   338

			uint cur_dist = DistanceManhattan(tile, st->xy);

   339

   340

			if (cur_dist < threshold) {

   341

				threshold = cur_dist;

   342

				best_station = st;

   343

			}

   344

		}

   345

	}

   346

   347

	return best_station;

   348

}

   349

   350

/** Update the virtual coords needed to draw the station sign.

   351

 * @param st Station to update for.

   352

 */

   353

static void UpdateStationVirtCoord(Station *st)

   354

{

   355

	Point pt = RemapCoords2(TileX(st->xy) * TILE_SIZE, TileY(st->xy) * TILE_SIZE);

   356

   357

	pt.y -= 32;

   358

	if (st->facilities & FACIL_AIRPORT && st->airport_type == AT_OILRIG) pt.y -= 16;

   359

   360

	SetDParam(0, st->index);

   361

	SetDParam(1, st->facilities);

   362

	UpdateViewportSignPos(&st->sign, pt.x, pt.y, STR_305C_0);

   363

}

   364

   365

/** Update the virtual coords needed to draw the station sign for all stations. */

   366

void UpdateAllStationVirtCoord()

   367

{

   368

	Station *st;

   369

   370

	FOR_ALL_STATIONS(st) {

   371

		UpdateStationVirtCoord(st);

   372

	}

   373

}

   374

   375

/**

   376

 * Update the station virt coords while making the modified parts dirty.

   377

 *

   378

 * This function updates the virt coords and mark the modified parts as dirty

   379

 *

   380

 * @param st The station to update the virt coords

   381

 * @ingroup dirty

   382

 */

   383

static void UpdateStationVirtCoordDirty(Station *st)

   384

{

   385

	st->MarkDirty();

   386

	UpdateStationVirtCoord(st);

   387

	st->MarkDirty();

   388

}

   389

   390

/** Get a mask of the cargo types that the station accepts.

   391

 * @param st Station to query

   392

 * @return the expected mask

   393

 */

   394

static uint GetAcceptanceMask(const Station *st)

   395

{

   396

	uint mask = 0;

   397

   398

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

   399

		if (HasBit(st->goods[i].acceptance_pickup, GoodsEntry::ACCEPTANCE)) mask |= 1 << i;

   400

	}

   401

	return mask;

   402

}

   403

   404

/** Items contains the two cargo names that are to be accepted or rejected.

   405

 * msg is the string id of the message to display.

   406

 */

   407

static void ShowRejectOrAcceptNews(const Station *st, uint num_items, CargoID *cargo, StringID msg)

   408

{

   409

	for (uint i = 0; i < num_items; i++) {

   410

		SetDParam(i + 1, GetCargo(cargo[i])->name);

   411

	}

   412

   413

	SetDParam(0, st->index);

   414

	AddNewsItem(msg, NS_ACCEPTANCE, st->xy, 0);

   415

}

   416

   417

/**

   418

 * Get a list of the cargo types being produced around the tile (in a rectangle).

   419

 * @param produced: Destination array of produced cargo

   420

 * @param tile: Center of the search area

   421

 * @param w: Width of the center

   422

 * @param h: Height of the center

   423

 * @param rad: Radius of the search area

   424

 */

   425

void GetProductionAroundTiles(AcceptedCargo produced, TileIndex tile,

   426

	int w, int h, int rad)

   427

{

   428

	memset(produced, 0, sizeof(AcceptedCargo));

   429

   430

	int x = TileX(tile);

   431

	int y = TileY(tile);

   432

   433

	/* expand the region by rad tiles on each side

   434

	 * while making sure that we remain inside the board. */

   435

	int x2 = min(x + w + rad, MapSizeX());

   436

	int x1 = max(x - rad, 0);

   437

   438

	int y2 = min(y + h + rad, MapSizeY());

   439

	int y1 = max(y - rad, 0);

   440

   441

	assert(x1 < x2);

   442

	assert(y1 < y2);

   443

	assert(w > 0);

   444

	assert(h > 0);

   445

   446

	for (int yc = y1; yc != y2; yc++) {

   447

		for (int xc = x1; xc != x2; xc++) {

   448

			TileIndex tile = TileXY(xc, yc);

   449

   450

			if (!IsTileType(tile, MP_STATION)) {

   451

				GetProducedCargoProc *gpc = _tile_type_procs[GetTileType(tile)]->get_produced_cargo_proc;

   452

				if (gpc != NULL) {

   453

					CargoID cargos[256]; // Required for CBID_HOUSE_PRODUCE_CARGO.

   454

					memset(cargos, CT_INVALID, 256);

   455

   456

					gpc(tile, cargos);

   457

					for (uint i = 0; i < lengthof(cargos); ++i) {

   458

						if (cargos[i] != CT_INVALID) produced[cargos[i]]++;

   459

					}

   460

				}

   461

			}

   462

		}

   463

	}

   464

}

   465

   466

/**

   467

 * Get a list of the cargo types that are accepted around the tile.

   468

 * @param accepts: Destination array of accepted cargo

   469

 * @param tile: Center of the search area

   470

 * @param w: Width of the center

   471

 * @param h: Height of the center

   472

 * @param rad: Radius of the rectangular search area

   473

 */

   474

void GetAcceptanceAroundTiles(AcceptedCargo accepts, TileIndex tile,

   475

	int w, int h, int rad)

   476

{

   477

	memset(accepts, 0, sizeof(AcceptedCargo));

   478

   479

	int x = TileX(tile);

   480

	int y = TileY(tile);

   481

   482

	/* expand the region by rad tiles on each side

   483

	 * while making sure that we remain inside the board. */

   484

	int x2 = min(x + w + rad, MapSizeX());

   485

	int y2 = min(y + h + rad, MapSizeY());

   486

	int x1 = max(x - rad, 0);

   487

	int y1 = max(y - rad, 0);

   488

   489

	assert(x1 < x2);