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

#define CHECK_STATIONS_ERR ((Station*)-1)

   101

   102

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

   103

{

   104

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

   105

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

   106

		if (IsTileType(tile_cur, MP_STATION)) {

   107

			StationID t = GetStationIndex(tile_cur);

   108

   109

			if (closest_station == INVALID_STATION) {

   110

				closest_station = t;

   111

			} else if (closest_station != t) {

   112

				_error_message = STR_3006_ADJOINS_MORE_THAN_ONE_EXISTING;

   113

				return CHECK_STATIONS_ERR;

   114

			}

   115

		}

   116

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

   117

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

   118

}

   119

   120

/**

   121

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

   122

 * @param tile the tile to check

   123

 * @return true if it matches, false otherwise

   124

 */

   125

typedef bool (*CMSAMatcher)(TileIndex tile);

   126

   127

/**

   128

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

   129

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

   130

 * @param type the type of tile searched for

   131

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

   132

 *                 in all other cases this parameter is ignored

   133

 * @return the result the noumber of matching tiles around

   134

 */

   135

static int CountMapSquareAround(TileIndex tile, CMSAMatcher cmp)

   136

{

   137

	int num = 0;

   138

   139

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

   140

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

   141

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

   142

		}

   143

	}

   144

   145

	return num;

   146

}

   147

   148

/**

   149

 * Check whether the tile is a mine.

   150

 * @param tile the tile to investigate.

   151

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

   152

 */

   153

static bool CMSAMine(TileIndex tile)

   154

{

   155

	/* No industry */

   156

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

   157

   158

	const Industry *ind = GetIndustryByTile(tile);

   159

   160

	/* No extractive industry */

   161

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

   162

   163

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

   164

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

   165

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

   166

	}

   167

   168

	return false;

   169

}

   170

   171

/**

   172

 * Check whether the tile is water.

   173

 * @param tile the tile to investigate.

   174

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

   175

 */

   176

static bool CMSAWater(TileIndex tile)

   177

{

   178

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

   179

}

   180

   181

/**

   182

 * Check whether the tile is a tree.

   183

 * @param tile the tile to investigate.

   184

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

   185

 */

   186

static bool CMSATree(TileIndex tile)

   187

{

   188

	return IsTileType(tile, MP_TREES);

   189

}

   190

   191

/**

   192

 * Check whether the tile is a forest.

   193

 * @param tile the tile to investigate.

   194

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

   195

 */

   196

static bool CMSAForest(TileIndex tile)

   197

{

   198

	/* No industry */

   199

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

   200

   201

	const Industry *ind = GetIndustryByTile(tile);

   202

   203

	/* No extractive industry */

   204

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

   205

   206

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

   207

		/* The industry produces wood. */

   208

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

   209

	}

   210

   211

	return false;

   212

}

   213

   214

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

   215

   216

enum StationNaming {

   217

	STATIONNAMING_RAIL = 0,

   218

	STATIONNAMING_ROAD = 0,

   219

	STATIONNAMING_AIRPORT,

   220

	STATIONNAMING_OILRIG,

   221

	STATIONNAMING_DOCK,

   222

	STATIONNAMING_BUOY,

   223

	STATIONNAMING_HELIPORT,

   224

};

   225

   226

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

   227

{

   228

	static const uint32 _gen_station_name_bits[] = {

   229

		0,                                      /* 0 */

   230

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

   231

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

   232

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

   233

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

   234

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

   235

	};

   236

   237

	const Town *t = st->town;

   238

	uint32 free_names = UINT32_MAX;

   239

   240

	const Station *s;

   241

	FOR_ALL_STATIONS(s) {

   242

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

   243

			uint str = M(s->string_id);

   244

			if (str <= 0x20) {

   245

				if (str == M(STR_SV_STNAME_FOREST)) {

   246

					str = M(STR_SV_STNAME_WOODS);

   247

				}

   248

				ClrBit(free_names, str);

   249

			}

   250

		}

   251

	}

   252

   253

	/* check default names */

   254

	uint32 tmp = free_names & _gen_station_name_bits[flag];

   255

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

   256

   257

	/* check mine? */

   258

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

   259

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

   260

			return STR_SV_STNAME_MINES;

   261

		}

   262

	}

   263

   264

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

   265

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

   266

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

   267

   268

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

   269

	}

   270

   271

	/* Check lakeside */

   272

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

   273

			DistanceFromEdge(tile) < 20 &&

   274

			CountMapSquareAround(tile, CMSAWater) >= 5) {

   275

		return STR_SV_STNAME_LAKESIDE;

   276

	}

   277

   278

	/* Check woods */

   279

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

   280

				CountMapSquareAround(tile, CMSATree) >= 8 ||

   281

				CountMapSquareAround(tile, CMSAForest) >= 2)

   282

			) {

   283

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

   284

	}

   285

   286

	/* check elevation compared to town */

   287

	uint z = GetTileZ(tile);

   288

	uint z2 = GetTileZ(t->xy);

   289

	if (z < z2) {

   290

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

   291

	} else if (z > z2) {

   292

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

   293

	}

   294

   295

	/* check direction compared to town */

   296

	static const int8 _direction_and_table[] = {

   297

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

   298

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

   299

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

   300

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

   301

	};

   302

   303

	free_names &= _direction_and_table[

   304

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

   305

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

   306

   307

	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));

   308

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

   309

}

   310

#undef M

   311

   312

static Station *GetClosestStationFromTile(TileIndex tile)

   313

{

   314

	uint threshold = 8;

   315

	Station *best_station = NULL;

   316

	Station *st;

   317

   318

	FOR_ALL_STATIONS(st) {

   319

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

   320

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

   321

   322

			if (cur_dist < threshold) {

   323

				threshold = cur_dist;

   324

				best_station = st;

   325

			}

   326

		}

   327

	}

   328

   329

	return best_station;

   330

}

   331

   332

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

   333

 * @param st Station to update for.

   334

 */

   335

static void UpdateStationVirtCoord(Station *st)

   336

{

   337

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

   338

   339

	pt.y -= 32;

   340

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

   341

   342

	SetDParam(0, st->index);

   343

	SetDParam(1, st->facilities);

   344

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

   345

}

   346

   347

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

   348

void UpdateAllStationVirtCoord()

   349

{

   350

	Station *st;

   351

   352

	FOR_ALL_STATIONS(st) {

   353

		UpdateStationVirtCoord(st);

   354

	}

   355

}

   356

   357

/**

   358

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

   359

 *

   360

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

   361

 *

   362

 * @param st The station to update the virt coords

   363

 * @ingroup dirty

   364

 */

   365

static void UpdateStationVirtCoordDirty(Station *st)

   366

{

   367

	st->MarkDirty();

   368

	UpdateStationVirtCoord(st);

   369

	st->MarkDirty();

   370

}

   371

   372

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

   373

 * @param st Station to query

   374

 * @return the expected mask

   375

 */

   376

static uint GetAcceptanceMask(const Station *st)

   377

{

   378

	uint mask = 0;

   379

   380

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

   381

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

   382

	}

   383

	return mask;

   384

}

   385

   386

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

   387

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

   388

 */

   389

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

   390

{

   391

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

   392

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

   393

	}

   394

   395

	SetDParam(0, st->index);

   396

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

   397

}

   398

   399

/**

   400

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

   401

 * @param produced: Destination array of produced cargo

   402

 * @param tile: Center of the search area

   403

 * @param w: Width of the center

   404

 * @param h: Height of the center

   405

 * @param rad: Radius of the search area

   406

 */

   407

void GetProductionAroundTiles(AcceptedCargo produced, TileIndex tile,

   408

	int w, int h, int rad)

   409

{

   410

	memset(produced, 0, sizeof(AcceptedCargo)); // sizeof(AcceptedCargo) != sizeof(produced) (== sizeof(uint *))

   411

   412

	int x = TileX(tile);

   413

	int y = TileY(tile);

   414

   415

	/* expand the region by rad tiles on each side

   416

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

   417

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

   418

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

   419

   420

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

   421

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

   422

   423

	assert(x1 < x2);

   424

	assert(y1 < y2);

   425

	assert(w > 0);

   426

	assert(h > 0);

   427

   428

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

   429

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

   430

			TileIndex tile = TileXY(xc, yc);

   431

   432

			if (!IsTileType(tile, MP_STATION)) {

   433

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

   434

				if (gpc != NULL) {

   435

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

   436

					memset(cargos, CT_INVALID, sizeof(cargos));

   437

   438

					gpc(tile, cargos);

   439

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

   440

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

   441

					}

   442

				}

   443

			}

   444

		}

   445

	}

   446

}

   447

   448

/**

   449

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

   450

 * @param accepts: Destination array of accepted cargo

   451

 * @param tile: Center of the search area

   452

 * @param w: Width of the center

   453

 * @param h: Height of the center

   454

 * @param rad: Radius of the rectangular search area

   455

 */

   456

void GetAcceptanceAroundTiles(AcceptedCargo accepts, TileIndex tile,

   457

	int w, int h, int rad)

   458

{

   459

	memset(accepts, 0, sizeof(AcceptedCargo)); // sizeof(AcceptedCargo) != sizeof(accepts) (== sizeof(uint *))

   460

   461

	int x = TileX(tile);

   462

	int y = TileY(tile);

   463

   464

	/* expand the region by rad tiles on each side

   465

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

   466

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

   467

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

   468

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

   469

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

   470

   471

	assert(x1 < x2);

   472

	assert(y1 < y2);

   473

	assert(w > 0);

   474

	assert(h > 0);

   475

   476

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

   477

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

   478

			TileIndex tile = TileXY(xc, yc);

   479

   480

			if (!IsTileType(tile, MP_STATION)) {

   481

				AcceptedCargo ac;

   482

   483

				GetAcceptedCargo(tile, ac);

   484

				for (uint i = 0; i < lengthof(ac); ++i) accepts[i] += ac[i];

   485

			}

   486

		}

   487

	}

   488

}

   489