1

#include "stdafx.h"

     2

#include "openttd.h"

     3

     4

#include "command.h"

     5

#include "gfx.h"

     6

#include "map.h"

     7

#include "order.h"

     8

#include "saveload.h"

     9

#include "station.h"

    10

#include "tile.h"

    11

#include "town.h"

    12

#include "waypoint.h"

    13

#include "table/sprites.h"

    14

#include "table/strings.h"

    15

#include "table/track_land.h"

    16

    17

enum {

    18

	/* Max waypoints: 64000 (8 * 8000) */

    19

	WAYPOINT_POOL_BLOCK_SIZE_BITS = 3,       /* In bits, so (1 << 3) == 8 */

    20

	WAYPOINT_POOL_MAX_BLOCKS      = 8000,

    21

    22

	MAX_WAYPOINTS_PER_TOWN        = 64,

    23

};

    24

    25

/**

    26

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

    27

 */

    28

static void WaypointPoolNewBlock(uint start_item)

    29

{

    30

	Waypoint *wp;

    31

    32

	FOR_ALL_WAYPOINTS_FROM(wp, start_item)

    33

		wp->index = start_item++;

    34

}

    35

    36

/* Initialize the town-pool */

    37

MemoryPool _waypoint_pool = { "Waypoints", WAYPOINT_POOL_MAX_BLOCKS, WAYPOINT_POOL_BLOCK_SIZE_BITS, sizeof(Waypoint), &WaypointPoolNewBlock, 0, 0, NULL };

    38

    39

/* Create a new waypoint */

    40

Waypoint *AllocateWaypoint(void)

    41

{

    42

	Waypoint *wp;

    43

    44

	FOR_ALL_WAYPOINTS(wp) {

    45

		if (wp->xy == 0) {

    46

			uint index = wp->index;

    47

    48

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

    49

			wp->index = index;

    50

    51

			return wp;

    52

		}

    53

	}

    54

    55

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

    56

	if (AddBlockToPool(&_waypoint_pool))

    57

		return AllocateWaypoint();

    58

    59

	return NULL;

    60

}

    61

    62

/* Fetch a waypoint by tile */

    63

Waypoint *GetWaypointByTile(TileIndex tile)

    64

{

    65

	Waypoint *wp;

    66

    67

	FOR_ALL_WAYPOINTS(wp) {

    68

		if (wp->xy == tile)

    69

			return wp;

    70

	}

    71

    72

	return NULL;

    73

}

    74

    75

/* Update the sign for the waypoint */

    76

void UpdateWaypointSign(Waypoint *wp)

    77

{

    78

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

    79

	SetDParam(0, wp->index);

    80

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

    81

}

    82

    83

/* Redraw the sign of a waypoint */

    84

void RedrawWaypointSign(Waypoint *wp)

    85

{

    86

	MarkAllViewportsDirty(

    87

		wp->sign.left - 6,

    88

		wp->sign.top,

    89

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

    90

		wp->sign.top + 48);

    91

}

    92

    93

/* Update all signs */

    94

void UpdateAllWaypointSigns(void)

    95

{

    96

	Waypoint *wp;

    97

    98

	FOR_ALL_WAYPOINTS(wp) {

    99

		if (wp->xy)

   100

			UpdateWaypointSign(wp);

   101

	}

   102

}

   103

   104

/* Set the default name for a waypoint */

   105

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)

   118

			continue;

   119

   120

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

   121

			used_waypoint[local_wp->town_cn] = true;

   122

	}

   123

   124

	/* Find an empty spot */

   125

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

   126

   127

	wp->string = STR_NULL;

   128

	wp->town_cn = i;

   129

}

   130

   131

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

   132

static Waypoint *FindDeletedWaypointCloseTo(TileIndex tile)

   133

{

   134

	Waypoint *wp, *best = NULL;

   135

	uint thres = 8, cur_dist;

   136

   137

	FOR_ALL_WAYPOINTS(wp) {

   138

		if (wp->deleted && wp->xy) {

   139

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

   140

			if (cur_dist < thres) {

   141

				thres = cur_dist;

   142

				best = wp;

   143

			}

   144

		}

   145

	}

   146

   147

	return best;

   148

}

   149

   150

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

   151

 * piece of rail

   152

 * @param x,y coordinates where waypoint will be built

   153

 * @param p1 graphics for waypoint type, bit 8 signifies custom waypoint gfx (& 0x100)

   154

 * @param p2 unused

   155

 */

   156

int32 CmdBuildTrainWaypoint(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   157

{

   159

	Waypoint *wp;

   160

	uint tileh;

   161

	uint dir;

   162

   163

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   164

   165

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

   166

	if (p1 > 0x100 + (uint)GetCustomStationsCount(STAT_CLASS_WAYP)) return CMD_ERROR;

   167

   168

	if (!IsTileType(tile, MP_RAILWAY) || ((dir = 0, _map5[tile] != 1) && (dir = 1, _map5[tile] != 2)))

   169

		return_cmd_error(STR_1005_NO_SUITABLE_RAILROAD_TRACK);

   170

   171

	if (!CheckTileOwnership(tile))

   172

		return CMD_ERROR;

   173

   174

	if (!EnsureNoVehicle(tile)) return CMD_ERROR;

   175

   176

	tileh = GetTileSlope(tile, NULL);

   177

	if (tileh != 0) {

   178

		if (!_patches.build_on_slopes || tileh & 0x10 || !(tileh & (0x3 << dir)) || !(tileh & ~(0x3 << dir)))

   179

			return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);

   180

	}

   181

   182

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

   183

	wp = FindDeletedWaypointCloseTo(tile);

   184

	if (wp == NULL) {

   185

		wp = AllocateWaypoint();

   186

		if (wp == NULL) return CMD_ERROR;

   187

   188

		wp->town_index = 0;

   189

		wp->string = STR_NULL;

   190

		wp->town_cn = 0;

   191

	}

   192

   193

	if (flags & DC_EXEC) {

   194

		ModifyTile(tile, MP_MAP5, RAIL_TYPE_WAYPOINT | dir);

   195

		if (--p1 & 0x100) { // waypoint type 0 uses default graphics

   196

			// custom graphics

   197

			_map3_lo[tile] |= 16;

   198

			_map3_hi[tile] = p1 & 0xff;

   199

		}

   200

   201

		wp->deleted = 0;

   202

		wp->xy = tile;

   203

		wp->build_date = _date;

   204

   205

		if (wp->town_index == STR_NULL)

   206

			MakeDefaultWaypointName(wp);

   207

   208

		UpdateWaypointSign(wp);

   209

		RedrawWaypointSign(wp);

   210

	}

   211

   212

	return _price.build_train_depot;

   213

}

   214

   215

/* Internal handler to delete a waypoint */

   216

static void DoDeleteWaypoint(Waypoint *wp)

   217

{

   218

	Order order;

   219

   220

	wp->xy = 0;

   221

   222

	order.type = OT_GOTO_WAYPOINT;

   223

	order.station = wp->index;

   224

	DeleteDestinationFromVehicleOrder(order);

   225

   226

	if (wp->string != STR_NULL)

   227

		DeleteName(wp->string);

   228

   229

	RedrawWaypointSign(wp);

   230

}

   231

   232

/* Daily loop for waypoints */

   233

void WaypointsDailyLoop(void)

   234

{

   235

	Waypoint *wp;

   236

   237

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

   238

	FOR_ALL_WAYPOINTS(wp) {

   239

		if (wp->deleted && !--wp->deleted) {

   240

			DoDeleteWaypoint(wp);

   241

		}

   242

	}

   243

}

   244

   245

/* Remove a waypoint */

   246

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

   247

{

   248

	Waypoint *wp;

   249

   250

	/* Make sure it's a waypoint */

   251

	if (!IsTileType(tile, MP_RAILWAY) || !IsRailWaypoint(_map5[tile]))

   252

		return CMD_ERROR;

   253

   254

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

   255

		return CMD_ERROR;

   256

   257

	if (!EnsureNoVehicle(tile))

   258

		return CMD_ERROR;

   259

   260

	if (flags & DC_EXEC) {

   261

		int direction = _map5[tile] & RAIL_WAYPOINT_TRACK_MASK;

   262

   263

		wp = GetWaypointByTile(tile);

   264

   265

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

   266

		RedrawWaypointSign(wp);

   267

   268

		if (justremove) {

   269

			ModifyTile(tile, MP_MAP5, 1<<direction);

   270

			_map3_lo[tile] &= ~16;

   271

			_map3_hi[tile] = 0;

   272

		} else {

   273

			DoClearSquare(tile);

   274

			SetSignalsOnBothDir(tile, direction);

   275

		}

   276

	}

   277

   278

	return _price.remove_train_depot;

   279

}

   280

   281

/** Delete a waypoint

   282

 * @param x,y coordinates where waypoint is to be deleted

   283

 * @param p1 unused

   284

 * @param p2 unused

   285

 */

   286

int32 CmdRemoveTrainWaypoint(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   287

{

   289

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   290

	return RemoveTrainWaypoint(tile, flags, true);

   291

}

   292

   293

/** Rename a waypoint.

   294

 * @param x,y unused

   295

 * @param p1 id of waypoint

   296

 * @param p2 unused

   297

 */

   298

int32 CmdRenameWaypoint(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   299

{

   300

	Waypoint *wp;

   301

	StringID str;

   302

   303

	if (!IsWaypointIndex(p1)) return CMD_ERROR;

   304

   305

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

   306

		str = AllocateNameUnique(_cmd_text, 0);

   307

		if (str == 0)

   308

			return CMD_ERROR;

   309

   310

		if (flags & DC_EXEC) {

   311

			wp = GetWaypoint(p1);

   312

			if (wp->string != STR_NULL)

   313

				DeleteName(wp->string);

   314

   315

			wp->string = str;

   316

			wp->town_cn = 0;

   317

   318

			UpdateWaypointSign(wp);

   319

			MarkWholeScreenDirty();

   320

		} else {

   321

			DeleteName(str);

   322

		}

   323

	}	else {

   324

		if (flags & DC_EXEC) {

   325

			wp = GetWaypoint(p1);

   326

			if (wp->string != STR_NULL)

   327

				DeleteName(wp->string);

   328

   329

			MakeDefaultWaypointName(wp);

   330

			UpdateWaypointSign(wp);

   331

			MarkWholeScreenDirty();

   332

		}

   333

	}

   334

	return 0;

   335

}

   336

   337

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

   338

Station *ComposeWaypointStation(TileIndex tile)

   339

{

   340

	Waypoint *wp = GetWaypointByTile(tile);

   341

	static Station stat;

   342

   343

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

   344

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

   345

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

   346

	stat.build_date = wp->build_date;

   347

	stat.class_id = 6;

   348

	stat.stat_id = wp->stat_id;

   349

   350

	return &stat;

   351

}

   352

   353

extern uint16 _custom_sprites_base;

   354

   355

/* Draw a waypoint */

   356

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

   357

{

   358

	StationSpec *stat;

   359

	uint32 relocation;

   360

	DrawTileSprites *cust;

   361

	DrawTileSeqStruct const *seq;

   362

	uint32 ormod, img;

   363

   364

	ormod = SPRITE_PALETTE(PLAYER_SPRITE_COLOR(_local_player));

   365

   366

	x += 33;

   367

	y += 17;

   368

   369

	/* draw default waypoint graphics of ID 0 */

   370

	if (stat_id == 0) {

   371

		const DrawTrackSeqStruct *dtss = _track_depot_layout_table[4];

   372

   373

		img = dtss++->image;

   374

		if (img & 0x8000) img = (img & 0x7FFF) + railtype*TRACKTYPE_SPRITE_PITCH;

   375

		DrawSprite(img, x, y);

   376

   377

		for (; dtss->image != 0; dtss++) {

   378

			Point pt = RemapCoords(dtss->subcoord_x, dtss->subcoord_y, 0);

   379

			img = dtss->image;

   380

			if (img & 0x8000) img |= ormod;

   381

			DrawSprite(img, x + pt.x, y + pt.y);

   382

		}

   383

		return;

   384

	}

   385

   386

	stat = GetCustomStation(STAT_CLASS_WAYP, stat_id - 1);

   387

	assert(stat);

   388

	relocation = GetCustomStationRelocation(stat, NULL, 1);

   389

	// emulate station tile - open with building

   390

	// add 1 to get the other direction

   391

	cust = &stat->renderdata[2];

   392

   393

	img = cust->ground_sprite;

   394

	img += railtype * ((img < _custom_sprites_base) ? TRACKTYPE_SPRITE_PITCH : 1);

   395

   396

	if (img & 0x8000) img = (img & 0x7FFF);

   397

	DrawSprite(img, x, y);

   398

   399

	foreach_draw_tile_seq(seq, cust->seq) {

   400

		Point pt = RemapCoords(seq->delta_x, seq->delta_y, seq->delta_z);

   401

		uint32 image = seq->image + relocation;

   402

   403

		DrawSprite((image&0x3FFF) | ormod, x + pt.x, y + pt.y);

   404

	}

   405

}

   406

   407

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

   408

void FixOldWaypoints(void)

   409

{

   410

	Waypoint *wp;

   411

   412

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

   413

	FOR_ALL_WAYPOINTS(wp) {

   414

		if (wp->xy == 0)

   415

			continue;

   416

   417

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

   418

		wp->town_cn = 0;

   419

		if (wp->string & 0xC000) {

   420

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

   421

			wp->string = STR_NULL;

   422

		}

   423

	}

   424

}

   425

   426

void InitializeWaypoints(void)

   427

{

   428

	CleanPool(&_waypoint_pool);

   429

	AddBlockToPool(&_waypoint_pool);

   430

}

   431

   432

static const SaveLoad _waypoint_desc[] = {

   433

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

   434

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

   435

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

   436

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

   437

	SLE_VAR(Waypoint,string,		SLE_UINT16),

   438

	SLE_VAR(Waypoint,deleted,						SLE_UINT8),

   439

   440

	SLE_CONDVAR(Waypoint, build_date, SLE_UINT16, 3, 255),

   441

	SLE_CONDVAR(Waypoint, stat_id, SLE_UINT8, 3, 255),

   442

   443

	SLE_END()

   444

};

   445

   446

static void Save_WAYP(void)

   447

{

   448

	Waypoint *wp;

   449

   450

	FOR_ALL_WAYPOINTS(wp) {

   451

		if (wp->xy != 0) {

   452

			SlSetArrayIndex(wp->index);

   453

			SlObject(wp, _waypoint_desc);

   454

		}

   455

	}

   456

}

   457

   458

static void Load_WAYP(void)

   459

{

   460

	int index;

   461

   462

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

   463

		Waypoint *wp;

   464

   465

		if (!AddBlockIfNeeded(&_waypoint_pool, index))

   466

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

   467

   468

		wp = GetWaypoint(index);

   469

		SlObject(wp, _waypoint_desc);

   470

	}

   471

}

   472

   473

const ChunkHandler _waypoint_chunk_handlers[] = {

   474

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

   475

};