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

    28

#include "yapf/yapf.h"

    29

#include "road_type.h"

    30

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

    31

#include "cargotype.h"

    32

#include "variables.h"

    33

#include "autoslope.h"

    34

#include "transparency.h"

    35

#include "water.h"

    36

#include "station_gui.h"

    37

#include "strings_func.h"

    38

#include "functions.h"

    39

#include "window_func.h"

    40

#include "date_func.h"

    41

#include "vehicle_func.h"

    42

#include "string_func.h"

    43

#include "signal_func.h"

    44

#include "oldpool_func.h"

    45

#include "animated_tile_func.h"

    46

#include "elrail_func.h"

    47

#include "newgrf.h"

    48

#include "core/smallvec_type.hpp"

    49

    50

#include "table/sprites.h"

    51

#include "table/strings.h"

    52

    53

DEFINE_OLD_POOL_GENERIC(Station, Station)

    54

DEFINE_OLD_POOL_GENERIC(RoadStop, RoadStop)

    55

    56

    57

/**

    58

 * Check whether the given tile is a hangar.

    59

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

    60

 * @pre IsTileType(t, MP_STATION)

    61

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

    62

 */

    63

bool IsHangar(TileIndex t)

    64

{

    65

	assert(IsTileType(t, MP_STATION));

    66

    67

	const Station *st = GetStationByTile(t);

    68

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

    69

    70

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

    71

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

    72

	}

    73

    74

	return false;

    75

}

    76

    77

RoadStop *GetRoadStopByTile(TileIndex tile, RoadStopType type)

    78

{

    79

	const Station *st = GetStationByTile(tile);

    80

    81

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

    82

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

    83

		assert(rs->next != NULL);

    84

	}

    85

}

    86

    87

    88

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

    89

{

    90

	uint num = 0;

    91

    92

	assert(st != NULL);

    93

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

    94

		num++;

    95

	}

    96

    97

	return num;

    98

}

    99

   100

   101

#define CHECK_STATIONS_ERR ((Station*)-1)

   102

   103

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

   104

{

   105

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

   106

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

   107

		if (IsTileType(tile_cur, MP_STATION)) {

   108

			StationID t = GetStationIndex(tile_cur);

   109

   110

			if (closest_station == INVALID_STATION) {

   111

				closest_station = t;

   112

			} else if (closest_station != t) {

   113

				_error_message = STR_3006_ADJOINS_MORE_THAN_ONE_EXISTING;

   114

				return CHECK_STATIONS_ERR;

   115

			}

   116

		}

   117

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

   118

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

   119

}

   120

   121

/**

   122

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

   123

 * @param tile the tile to check

   124

 * @return true if it matches, false otherwise

   125

 */

   126

typedef bool (*CMSAMatcher)(TileIndex tile);

   127

   128

/**

   129

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

   130

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

   131

 * @param type the type of tile searched for

   132

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

   133

 *                 in all other cases this parameter is ignored

   134

 * @return the result the noumber of matching tiles around

   135

 */

   136

static int CountMapSquareAround(TileIndex tile, CMSAMatcher cmp)

   137

{

   138

	int num = 0;

   139

   140

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

   141

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

   142

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

   143

		}

   144

	}

   145

   146

	return num;

   147

}

   148

   149

/**

   150

 * Check whether the tile is a mine.

   151

 * @param tile the tile to investigate.

   152

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

   153

 */

   154

static bool CMSAMine(TileIndex tile)

   155

{

   156

	/* No industry */

   157

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

   158

   159

	const Industry *ind = GetIndustryByTile(tile);

   160

   161

	/* No extractive industry */

   162

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

   163

   164

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

   165

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

   166

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

   167

	}

   168

   169

	return false;

   170

}

   171

   172

/**

   173

 * Check whether the tile is water.

   174

 * @param tile the tile to investigate.

   175

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

   176

 */

   177

static bool CMSAWater(TileIndex tile)

   178

{

   179

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

   180

}

   181

   182

/**

   183

 * Check whether the tile is a tree.

   184

 * @param tile the tile to investigate.

   185

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

   186

 */

   187

static bool CMSATree(TileIndex tile)

   188

{

   189

	return IsTileType(tile, MP_TREES);

   190

}

   191

   192

/**

   193

 * Check whether the tile is a forest.

   194

 * @param tile the tile to investigate.

   195

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

   196

 */

   197

static bool CMSAForest(TileIndex tile)

   198

{

   199

	/* No industry */

   200

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

   201

   202

	const Industry *ind = GetIndustryByTile(tile);

   203

   204

	/* No extractive industry */

   205

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

   206

   207

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

   208

		/* The industry produces wood. */

   209

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

   210

	}

   211

   212

	return false;

   213

}

   214

   215

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

   216

   217

enum StationNaming {

   218

	STATIONNAMING_RAIL = 0,

   219

	STATIONNAMING_ROAD = 0,

   220

	STATIONNAMING_AIRPORT,

   221

	STATIONNAMING_OILRIG,

   222

	STATIONNAMING_DOCK,

   223

	STATIONNAMING_BUOY,

   224

	STATIONNAMING_HELIPORT,

   225

};

   226

   227

/** Information to handle station action 0 property 24 correctly */

   228

struct StationNameInformation {

   229

	uint32 free_names; ///< Current bitset of free names (we can remove names).

   230

	bool *indtypes;    ///< Array of bools telling whether an industry type has been found.

   231

};

   232

   233

/**

   234

 * Find a station action 0 property 24 station name, or reduce the

   235

 * free_names if needed.

   236

 * @param tile the tile to search

   237

 * @param user_data the StationNameInformation to base the search on

   238

 * @return true if the tile contains an industry that has not given

   239

 *              it's name to one of the other stations in town.

   240

 */

   241

static bool FindNearIndustryName(TileIndex tile, void *user_data)

   242

{

   243

	/* All already found industry types */

   244

	StationNameInformation *sni = (StationNameInformation*)user_data;

   245

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

   246

   247

	/* If the station name is undefined it means that it doesn't name a station */

   248

	IndustryType indtype = GetIndustryType(tile);

   249

	if (GetIndustrySpec(indtype)->station_name == STR_UNDEFINED) return false;

   250

   251

	/* In all cases if an industry that provides a name is found two of

   252

	 * the standard names will be disabled. */

   253

	sni->free_names &= ~(1 << M(STR_SV_STNAME_OILFIELD) | 1 << M(STR_SV_STNAME_MINES));

   254

	return !sni->indtypes[indtype];

   255

}

   256

   257

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

   258

{

   259

	static const uint32 _gen_station_name_bits[] = {

   260

		0,                                      /* 0 */

   261

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

   262

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

   263

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

   264

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

   265

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

   266

	};

   267

   268

	const Town *t = st->town;

   269

	uint32 free_names = UINT32_MAX;

   270

   271

	bool indtypes[NUM_INDUSTRYTYPES];

   272

	memset(indtypes, 0, sizeof(indtypes));

   273

   274

	const Station *s;

   275

	FOR_ALL_STATIONS(s) {

   276

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

   277

			if (s->indtype != IT_INVALID) {

   278

				indtypes[s->indtype] = true;

   279

				continue;

   280

			}

   281

			uint str = M(s->string_id);

   282

			if (str <= 0x20) {

   283

				if (str == M(STR_SV_STNAME_FOREST)) {

   284

					str = M(STR_SV_STNAME_WOODS);

   285

				}

   286

				ClrBit(free_names, str);

   287

			}

   288

		}

   289

	}

   290

   291

	if (flag != STATIONNAMING_BUOY) {

   292

		TileIndex indtile = tile;

   293

		StationNameInformation sni = { free_names, indtypes };

   294

		if (CircularTileSearch(&indtile, 7, FindNearIndustryName, &sni)) {

   295

			/* An industry has been found nearby */

   296

			IndustryType indtype = GetIndustryType(indtile);

   297

			const IndustrySpec *indsp = GetIndustrySpec(indtype);

   298

			/* STR_NULL means it only disables oil rig/mines */

   299

			if (indsp->station_name != STR_NULL) {

   300

				st->indtype = indtype;

   301

				return STR_SV_STNAME_FALLBACK;

   302

			}

   303

		}

   304

   305

		/* Oil rigs/mines name could be marked not free by looking for a near by industry. */

   306

		free_names = sni.free_names;

   307

	}

   308

   309

	/* check default names */

   310

	uint32 tmp = free_names & _gen_station_name_bits[flag];

   311

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

   312

   313

	/* check mine? */

   314

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

   315

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

   316

			return STR_SV_STNAME_MINES;

   317

		}

   318

	}

   319

   320

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

   321

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

   322

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

   323

   324

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

   325

	}

   326

   327

	/* Check lakeside */

   328

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

   329

			DistanceFromEdge(tile) < 20 &&

   330

			CountMapSquareAround(tile, CMSAWater) >= 5) {

   331

		return STR_SV_STNAME_LAKESIDE;

   332

	}

   333

   334

	/* Check woods */

   335

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

   336

				CountMapSquareAround(tile, CMSATree) >= 8 ||

   337

				CountMapSquareAround(tile, CMSAForest) >= 2)

   338

			) {

   339

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

   340

	}

   341

   342

	/* check elevation compared to town */

   343

	uint z = GetTileZ(tile);

   344

	uint z2 = GetTileZ(t->xy);

   345

	if (z < z2) {

   346

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

   347

	} else if (z > z2) {

   348

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

   349

	}

   350

   351

	/* check direction compared to town */

   352

	static const int8 _direction_and_table[] = {

   353

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

   354

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

   355

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

   356

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

   357

	};

   358

   359

	free_names &= _direction_and_table[

   360

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

   361

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

   362

   363

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

   364

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

   365

}

   366

#undef M

   367

   368

static Station *GetClosestStationFromTile(TileIndex tile)

   369

{

   370

	uint threshold = 8;

   371

	Station *best_station = NULL;

   372

	Station *st;

   373

   374

	FOR_ALL_STATIONS(st) {

   375

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

   376

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

   377

   378

			if (cur_dist < threshold) {

   379

				threshold = cur_dist;

   380

				best_station = st;

   381

			}

   382

		}

   383

	}

   384

   385

	return best_station;

   386

}

   387

   388

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

   389

 * @param st Station to update for.

   390

 */

   391

static void UpdateStationVirtCoord(Station *st)

   392

{

   393

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

   394

   395

	pt.y -= 32;

   396

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

   397

   398

	SetDParam(0, st->index);

   399

	SetDParam(1, st->facilities);

   400

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

   401

}

   402

   403

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

   404

void UpdateAllStationVirtCoord()

   405

{

   406

	Station *st;

   407

   408

	FOR_ALL_STATIONS(st) {

   409

		UpdateStationVirtCoord(st);

   410

	}

   411

}

   412

   413

/**

   414

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

   415

 *

   416

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

   417

 *

   418

 * @param st The station to update the virt coords

   419

 * @ingroup dirty

   420

 */

   421

static void UpdateStationVirtCoordDirty(Station *st)

   422

{

   423

	st->MarkDirty();

   424

	UpdateStationVirtCoord(st);

   425

	st->MarkDirty();

   426

}

   427

   428

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

   429

 * @param st Station to query

   430

 * @return the expected mask

   431

 */

   432

static uint GetAcceptanceMask(const Station *st)

   433

{

   434

	uint mask = 0;

   435

   436

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

   437

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

   438

	}

   439

	return mask;

   440

}

   441

   442

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

   443

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

   444

 */

   445

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

   446

{

   447

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

   448

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

   449

	}

   450

   451

	SetDParam(0, st->index);

   452

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

   453

}

   454

   455

/**

   456

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

   457

 * @param produced Destination array of produced cargo

   458

 * @param tile Northtile of area

   459

 * @param w X extent of the area

   460

 * @param h Y extent of the area

   461

 * @param rad Search radius in addition to the given area

   462

 */

   463

void GetProductionAroundTiles(AcceptedCargo produced, TileIndex tile,

   464

	int w, int h, int rad)

   465

{

   466

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

   467

   468

	int x = TileX(tile);

   469

	int y = TileY(tile);

   470

   471

	/* expand the region by rad tiles on each side

   472

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

   473

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

   474

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

   475

   476

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

   477

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

   478

   479

	assert(x1 < x2);

   480

	assert(y1 < y2);

   481

	assert(w > 0);

   482

	assert(h > 0);

   483

   484

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

   485

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

   486

			TileIndex tile = TileXY(xc, yc);

   487

   488

			if (!IsTileType(tile, MP_STATION)) {

   489

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