1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

     6

#include "command.h"

     7

#include "functions.h"

     8

#include "gfx.h"

     9

#include "map.h"

    10

#include "order.h"

    11

#include "rail_map.h"

    12

#include "bridge_map.h"

    13

#include "saveload.h"

    14

#include "station.h"

    15

#include "tile.h"

    16

#include "town.h"

    17

#include "waypoint.h"

    18

#include "variables.h"

    19

#include "table/strings.h"

    20

#include "vehicle.h"

    21

#include "yapf/yapf.h"

    22

#include "date.h"

    23

    24

enum {

    25

	MAX_WAYPOINTS_PER_TOWN = 64,

    26

};

    27

    28

/**

    29

 * Called if a new block is added to the waypoint-pool

    30

 */

    31

static void WaypointPoolNewBlock(uint start_item)

    32

{

    33

	Waypoint *wp;

    34

    35

	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.

    36

	 * TODO - This is just a temporary stage, this will be removed. */

    37

	for (wp = GetWaypoint(start_item); wp != NULL; wp = (wp->index + 1U < GetWaypointPoolSize()) ? GetWaypoint(wp->index + 1U) : NULL) wp->index = start_item++;

    38

}

    39

    40

DEFINE_OLD_POOL(Waypoint, Waypoint, WaypointPoolNewBlock, NULL)

    41

    42

/* Create a new waypoint */

    43

static Waypoint* AllocateWaypoint(void)

    44

{

    45

	Waypoint *wp;

    46

    47

	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.

    48

	 * TODO - This is just a temporary stage, this will be removed. */

    49

	for (wp = GetWaypoint(0); wp != NULL; wp = (wp->index + 1U < GetWaypointPoolSize()) ? GetWaypoint(wp->index + 1U) : NULL) {

    50

		if (!IsValidWaypoint(wp)) {

    51

			uint index = wp->index;

    52

    53

			memset(wp, 0, sizeof(*wp));

    54

			wp->index = index;

    55

    56

			return wp;

    57

		}

    58

	}

    59

    60

	/* Check if we can add a block to the pool */

    61

	if (AddBlockToPool(&_Waypoint_pool)) return AllocateWaypoint();

    62

    63

	return NULL;

    64

}

    65

    66

/* Update the sign for the waypoint */

    67

static void UpdateWaypointSign(Waypoint* wp)

    68

{

    69

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

    70

	SetDParam(0, wp->index);

    71

	UpdateViewportSignPos(&wp->sign, pt.x, pt.y - 0x20, STR_WAYPOINT_VIEWPORT);

    72

}

    73

    74

/* Redraw the sign of a waypoint */

    75

static void RedrawWaypointSign(const Waypoint* wp)

    76

{

    77

	MarkAllViewportsDirty(

    78

		wp->sign.left - 6,

    79

		wp->sign.top,

    80

		wp->sign.left + (wp->sign.width_1 << 2) + 12,

    81

		wp->sign.top + 48);

    82

}

    83

    84

/* Update all signs */

    85

void UpdateAllWaypointSigns(void)

    86

{

    87

	Waypoint *wp;

    88

    89

	FOR_ALL_WAYPOINTS(wp) {

    90

		UpdateWaypointSign(wp);

    91

	}

    92

}

    93

    94

/* Internal handler to delete a waypoint */

    95

void DestroyWaypoint(Waypoint *wp)

    96

{

    97

	RemoveOrderFromAllVehicles(OT_GOTO_WAYPOINT, wp->index);

    98

    99

	if (wp->string != STR_NULL) DeleteName(wp->string);

   100

   101

	RedrawWaypointSign(wp);

   102

}

   103

   104

/* Set the default name for a waypoint */

   105

static void MakeDefaultWaypointName(Waypoint* wp)

   106

{

   107

	Waypoint *local_wp;

   108

	bool used_waypoint[MAX_WAYPOINTS_PER_TOWN];

   109

	int i;

   110

   111

	wp->town_index = ClosestTownFromTile(wp->xy, (uint)-1)->index;

   112

   113

	memset(used_waypoint, 0, sizeof(used_waypoint));

   114

   115

	/* Find an unused waypoint number belonging to this town */

   116

	FOR_ALL_WAYPOINTS(local_wp) {

   117

		if (wp == local_wp) continue;

   118

   119

		if (local_wp->xy && local_wp->string == STR_NULL && local_wp->town_index == wp->town_index)

   120

			used_waypoint[local_wp->town_cn] = true;

   121

	}

   122

   123

	/* Find an empty spot */

   124

	for (i = 0; used_waypoint[i] && i < MAX_WAYPOINTS_PER_TOWN; i++) {}

   125

   126

	wp->string = STR_NULL;

   127

	wp->town_cn = i;

   128

}

   129

   130

/* Find a deleted waypoint close to a tile. */

   131

static Waypoint *FindDeletedWaypointCloseTo(TileIndex tile)

   132

{

   133

	Waypoint *wp, *best = NULL;

   134

	uint thres = 8;

   135

   136

	FOR_ALL_WAYPOINTS(wp) {

   137

		if (wp->deleted) {

   138

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

   139

   140

			if (cur_dist < thres) {

   141

				thres = cur_dist;

   142

				best = wp;

   143

			}

   144

		}

   145

	}

   146

   147

	return best;

   148

}

   149

   150

/**

   151

 * Update waypoint graphics id against saved GRFID/localidx.

   152

 * This is to ensure the chosen graphics are correct if GRF files are changed.

   153

 */

   154

void AfterLoadWaypoints(void)

   155

{

   156

	Waypoint *wp;

   157

   158

	FOR_ALL_WAYPOINTS(wp) {

   159

		uint i;

   160

   161

		if (wp->grfid == 0) continue;

   162

   163

		for (i = 0; i < GetNumCustomStations(STAT_CLASS_WAYP); i++) {

   164

			const StationSpec *statspec = GetCustomStationSpec(STAT_CLASS_WAYP, i);

   165

			if (statspec != NULL && statspec->grfid == wp->grfid && statspec->localidx == wp->localidx) {

   166

				wp->stat_id = i;

   167

				break;

   168

			}

   169

		}

   170

	}

   171

}

   172

   173

/** Convert existing rail to waypoint. Eg build a waypoint station over

   174

 * piece of rail

   175

 * @param tile tile where waypoint will be built

   176

 * @param p1 graphics for waypoint type, 0 indicates standard graphics

   177

 * @param p2 unused

   178

 *

   179

 * @todo When checking for the tile slope,

   180

 * distingush between "Flat land required" and "land sloped in wrong direction"

   181

 */

   182

int32 CmdBuildTrainWaypoint(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   183

{

   184

	Waypoint *wp;

   185

	Slope tileh;

   186

	Axis axis;

   187

   188

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   189

   190

	/* if custom gfx are used, make sure it is within bounds */

   191

	if (p1 >= GetNumCustomStations(STAT_CLASS_WAYP)) return CMD_ERROR;

   192

   193

	if (!IsTileType(tile, MP_RAILWAY) ||

   194

			GetRailTileType(tile) != RAIL_TILE_NORMAL || (

   195

				(axis = AXIS_X, GetTrackBits(tile) != TRACK_BIT_X) &&

   196

				(axis = AXIS_Y, GetTrackBits(tile) != TRACK_BIT_Y)

   197

			)) {

   198

		return_cmd_error(STR_1005_NO_SUITABLE_RAILROAD_TRACK);

   199

	}

   200

   201

	if (!CheckTileOwnership(tile)) return CMD_ERROR;

   202

	if (!EnsureNoVehicle(tile)) return CMD_ERROR;

   203

   204

	tileh = GetTileSlope(tile, NULL);

   205

	if (tileh != SLOPE_FLAT &&

   206

			(!_patches.build_on_slopes || IsSteepSlope(tileh) || !(tileh & (0x3 << axis)) || !(tileh & ~(0x3 << axis)))) {

   207

		return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);

   208

	}

   209

   210

	if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);

   211

   212

	/* Check if there is an already existing, deleted, waypoint close to us that we can reuse. */

   213

	wp = FindDeletedWaypointCloseTo(tile);

   214

	if (wp == NULL) {

   215

		wp = AllocateWaypoint();

   216

		if (wp == NULL) return CMD_ERROR;

   217

   218

		wp->town_index = 0;

   219

		wp->string = STR_NULL;

   220

		wp->town_cn = 0;

   221

	}

   222

   223

	if (flags & DC_EXEC) {

   224

		const StationSpec* statspec;

   225

   226

		MakeRailWaypoint(tile, GetTileOwner(tile), axis, GetRailType(tile), wp->index);

   227

		MarkTileDirtyByTile(tile);

   228

   229

		statspec = GetCustomStationSpec(STAT_CLASS_WAYP, p1);

   230

   231

		if (statspec != NULL) {

   232

			wp->stat_id = p1;

   233

			wp->grfid = statspec->grfid;

   234

			wp->localidx = statspec->localidx;

   235

		} else {

   236

			// Specified custom graphics do not exist, so use default.

   237

			wp->stat_id = 0;

   238

			wp->grfid = 0;

   239

			wp->localidx = 0;

   240

		}

   241

   242

		wp->deleted = 0;

   243

		wp->xy = tile;

   244

		wp->build_date = _date;

   245

   246

		if (wp->town_index == 0) MakeDefaultWaypointName(wp);

   247

   248

		UpdateWaypointSign(wp);

   249

		RedrawWaypointSign(wp);

   250

		YapfNotifyTrackLayoutChange(tile, AxisToTrack(axis));

   251

	}

   252

   253

	return _price.build_train_depot;

   254

}

   255

   256

/* Daily loop for waypoints */

   257

void WaypointsDailyLoop(void)

   258

{

   259

	Waypoint *wp;

   260

   261

	/* Check if we need to delete a waypoint */

   262

	FOR_ALL_WAYPOINTS(wp) {

   263

		if (wp->deleted != 0 && --wp->deleted == 0) DeleteWaypoint(wp);

   264

	}

   265

}

   266

   267

/* Remove a waypoint */

   268

int32 RemoveTrainWaypoint(TileIndex tile, uint32 flags, bool justremove)

   269

{

   270

	Waypoint *wp;

   271

   272

	/* Make sure it's a waypoint */

   273

	if (!IsTileType(tile, MP_RAILWAY) ||

   274

			!IsRailWaypoint(tile) ||

   275

			(!CheckTileOwnership(tile) && _current_player != OWNER_WATER) ||

   276

			!EnsureNoVehicle(tile)) {

   277

		return CMD_ERROR;

   278

	}

   279

   280

	if (flags & DC_EXEC) {

   281

		Track track = GetRailWaypointTrack(tile);

   282

		wp = GetWaypointByTile(tile);

   283

   284

		wp->deleted = 30; // let it live for this many days before we do the actual deletion.

   285

		RedrawWaypointSign(wp);

   286

   287

		if (justremove) {

   288

			MakeRailNormal(tile, GetTileOwner(tile), GetRailWaypointBits(tile), GetRailType(tile));

   289

			MarkTileDirtyByTile(tile);

   290

		} else {

   291

			DoClearSquare(tile);

   292

			SetSignalsOnBothDir(tile, track);

   293

		}

   294

		YapfNotifyTrackLayoutChange(tile, track);

   295

	}

   296

   297

	return _price.remove_train_depot;

   298

}

   299

   300

/** Delete a waypoint

   301

 * @param tile tile where waypoint is to be deleted

   302

 * @param p1 unused

   303

 * @param p2 unused

   304

 */

   305

int32 CmdRemoveTrainWaypoint(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   306

{

   307

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   308

	return RemoveTrainWaypoint(tile, flags, true);

   309

}

   310

   311

/** Rename a waypoint.

   312

 * @param tile unused

   313

 * @param p1 id of waypoint

   314

 * @param p2 unused

   315

 */

   316

int32 CmdRenameWaypoint(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   317

{

   318

	Waypoint *wp;

   319

   320

	if (!IsValidWaypointID(p1)) return CMD_ERROR;

   321

   322

	if (_cmd_text[0] != '\0') {

   323

		StringID str = AllocateNameUnique(_cmd_text, 0);

   324

   325

		if (str == 0) return CMD_ERROR;

   326

   327

		if (flags & DC_EXEC) {

   328

			wp = GetWaypoint(p1);

   329

			if (wp->string != STR_NULL) DeleteName(wp->string);

   330

   331

			wp->string = str;

   332

			wp->town_cn = 0;

   333

   334

			UpdateWaypointSign(wp);

   335

			MarkWholeScreenDirty();

   336

		} else {

   337

			DeleteName(str);

   338

		}

   339

	} else {

   340

		if (flags & DC_EXEC) {

   341

			wp = GetWaypoint(p1);

   342

			if (wp->string != STR_NULL) DeleteName(wp->string);

   343

   344

			MakeDefaultWaypointName(wp);

   345

			UpdateWaypointSign(wp);

   346

			MarkWholeScreenDirty();

   347

		}

   348

	}

   349

	return 0;

   350

}

   351

   352

/* This hacks together some dummy one-shot Station structure for a waypoint. */

   353

Station *ComposeWaypointStation(TileIndex tile)

   354

{

   355

	Waypoint *wp = GetWaypointByTile(tile);

   356

	static Station stat;

   357

   358

	stat.train_tile = stat.xy = wp->xy;

   359

	stat.town = GetTown(wp->town_index);

   360

	stat.string_id = wp->string == STR_NULL ? /* FIXME? */ 0 : wp->string;

   361

	stat.build_date = wp->build_date;

   362

   363

	return &stat;

   364

}

   365

   366

/* Draw a waypoint */

   367

void DrawWaypointSprite(int x, int y, int stat_id, RailType railtype)

   368

{

   369

	x += 33;

   370

	y += 17;

   371

   372

	if (!DrawStationTile(x, y, railtype, AXIS_X, STAT_CLASS_WAYP, stat_id)) {

   373

		DrawDefaultWaypointSprite(x, y, railtype);

   374

	}

   375

}

   376

   377

/* Fix savegames which stored waypoints in their old format */

   378

void FixOldWaypoints(void)

   379

{

   380

	Waypoint *wp;

   381

   382

	/* Convert the old 'town_or_string', to 'string' / 'town' / 'town_cn' */

   383

	FOR_ALL_WAYPOINTS(wp) {

   384

		wp->town_index = ClosestTownFromTile(wp->xy, (uint)-1)->index;

   385

		wp->town_cn = 0;

   386

		if (wp->string & 0xC000) {

   387

			wp->town_cn = wp->string & 0x3F;

   388

			wp->string = STR_NULL;

   389

		}

   390

	}

   391

}

   392

   393

void InitializeWaypoints(void)

   394

{

   395

	CleanPool(&_Waypoint_pool);

   396

	AddBlockToPool(&_Waypoint_pool);

   397

}

   398

   399

static const SaveLoad _waypoint_desc[] = {

   400

	SLE_CONDVAR(Waypoint, xy,         SLE_FILE_U16 | SLE_VAR_U32,  0, 5),

   401

	SLE_CONDVAR(Waypoint, xy,         SLE_UINT32,                  6, SL_MAX_VERSION),

   402

	SLE_CONDVAR(Waypoint, town_index, SLE_UINT16,                 12, SL_MAX_VERSION),

   403

	SLE_CONDVAR(Waypoint, town_cn,    SLE_UINT8,                  12, SL_MAX_VERSION),

   404

	    SLE_VAR(Waypoint, string,     SLE_UINT16),

   405

	    SLE_VAR(Waypoint, deleted,    SLE_UINT8),

   406

   407

	SLE_CONDVAR(Waypoint, build_date, SLE_FILE_U16 | SLE_VAR_I32,  3, 30),

   408

	SLE_CONDVAR(Waypoint, build_date, SLE_INT32,                  31, SL_MAX_VERSION),

   409

	SLE_CONDVAR(Waypoint, localidx,   SLE_UINT8,                   3, SL_MAX_VERSION),

   410

	SLE_CONDVAR(Waypoint, grfid,      SLE_UINT32,                 17, SL_MAX_VERSION),

   411

   412

	SLE_END()

   413

};

   414

   415

static void Save_WAYP(void)

   416

{

   417

	Waypoint *wp;

   418

   419

	FOR_ALL_WAYPOINTS(wp) {

   420

		SlSetArrayIndex(wp->index);

   421

		SlObject(wp, _waypoint_desc);

   422

	}

   423

}

   424

   425

static void Load_WAYP(void)

   426

{

   427

	int index;

   428

   429

	while ((index = SlIterateArray()) != -1) {

   430

		Waypoint *wp;

   431

   432

		if (!AddBlockIfNeeded(&_Waypoint_pool, index))

   433

			error("Waypoints: failed loading savegame: too many waypoints");

   434

   435

		wp = GetWaypoint(index);

   436

		SlObject(wp, _waypoint_desc);

   437

	}

   438

}

   439

   440

const ChunkHandler _waypoint_chunk_handlers[] = {

   441

	{ 'CHKP', Save_WAYP, Load_WAYP, CH_ARRAY | CH_LAST},

   442

};